From 697e1d49416e9765b9aebc539d5f1ad4441dc46d Mon Sep 17 00:00:00 2001 From: raysan5 Date: Mon, 18 Jul 2016 14:53:11 +0200 Subject: [PATCH] Update pthreads library (win32) This library is only required by physac module to compulte physics in a second thread --- src/external/pthread/COPYING | 150 +++ src/external/pthread/include/pthread.h | 1368 ++++++++++++++++++++++ src/external/pthread/include/sched.h | 183 +++ src/external/pthread/include/semaphore.h | 169 +++ src/external/pthread/lib/libpthreadGC2.a | Bin 0 -> 93480 bytes src/external/pthread/pthreadGC2.dll | Bin 119888 -> 0 bytes 6 files changed, 1870 insertions(+) create mode 100644 src/external/pthread/COPYING create mode 100644 src/external/pthread/include/pthread.h create mode 100644 src/external/pthread/include/sched.h create mode 100644 src/external/pthread/include/semaphore.h create mode 100644 src/external/pthread/lib/libpthreadGC2.a delete mode 100644 src/external/pthread/pthreadGC2.dll diff --git a/src/external/pthread/COPYING b/src/external/pthread/COPYING new file mode 100644 index 000000000..5cfea0d0e --- /dev/null +++ b/src/external/pthread/COPYING @@ -0,0 +1,150 @@ + pthreads-win32 - a POSIX threads library for Microsoft Windows + + +This file is Copyrighted +------------------------ + + This file is covered under the following Copyright: + + Copyright (C) 2001,2006 Ross P. Johnson + All rights reserved. + + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +Pthreads-win32 is covered by the GNU Lesser General Public License +------------------------------------------------------------------ + + Pthreads-win32 is open software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public License + as published by the Free Software Foundation version 2.1 of the + License. + + Pthreads-win32 is several binary link libraries, several modules, + associated interface definition files and scripts used to control + its compilation and installation. + + Pthreads-win32 is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + A copy of the GNU Lesser General Public License is distributed with + pthreads-win32 under the filename: + + COPYING.LIB + + You should have received a copy of the version 2.1 GNU Lesser General + Public License with pthreads-win32; if not, write to: + + Free Software Foundation, Inc. + 59 Temple Place + Suite 330 + Boston, MA 02111-1307 + USA + + The contact addresses for pthreads-win32 is as follows: + + Web: http://sources.redhat.com/pthreads-win32 + Email: Ross Johnson + Please use: Firstname.Lastname@homemail.com.au + + + +Pthreads-win32 copyrights and exception files +--------------------------------------------- + + With the exception of the files listed below, Pthreads-win32 + is covered under the following GNU Lesser General Public License + Copyrights: + + Pthreads-win32 - POSIX Threads Library for Win32 + Copyright(C) 1998 John E. Bossom + Copyright(C) 1999,2006 Pthreads-win32 contributors + + The current list of contributors is contained + in the file CONTRIBUTORS included with the source + code distribution. The current list of CONTRIBUTORS + can also be seen at the following WWW location: + http://sources.redhat.com/pthreads-win32/contributors.html + + Contact Email: Ross Johnson + Please use: Firstname.Lastname@homemail.com.au + + These files are not covered under one of the Copyrights listed above: + + COPYING + COPYING.LIB + tests/rwlock7.c + + This file, COPYING, is distributed under the Copyright found at the + top of this file. It is important to note that you may distribute + verbatim copies of this file but you may not modify this file. + + The file COPYING.LIB, which contains a copy of the version 2.1 + GNU Lesser General Public License, is itself copyrighted by the + Free Software Foundation, Inc. Please note that the Free Software + Foundation, Inc. does NOT have a copyright over Pthreads-win32, + only the COPYING.LIB that is supplied with pthreads-win32. + + The file tests/rwlock7.c is derived from code written by + Dave Butenhof for his book 'Programming With POSIX(R) Threads'. + The original code was obtained by free download from his website + http://home.earthlink.net/~anneart/family/Threads/source.html + and did not contain a copyright or author notice. It is assumed to + be freely distributable. + + In all cases one may use and distribute these exception files freely. + And because one may freely distribute the LGPL covered files, the + entire pthreads-win32 source may be freely used and distributed. + + + +General Copyleft and License info +--------------------------------- + + For general information on Copylefts, see: + + http://www.gnu.org/copyleft/ + + For information on GNU Lesser General Public Licenses, see: + + http://www.gnu.org/copyleft/lesser.html + http://www.gnu.org/copyleft/lesser.txt + + +Why pthreads-win32 did not use the GNU General Public License +------------------------------------------------------------- + + The goal of the pthreads-win32 project has been to + provide a quality and complete implementation of the POSIX + threads API for Microsoft Windows within the limits imposed + by virtue of it being a stand-alone library and not + linked directly to other POSIX compliant libraries. For + example, some functions and features, such as those based + on POSIX signals, are missing. + + Pthreads-win32 is a library, available in several different + versions depending on supported compilers, and may be used + as a dynamically linked module or a statically linked set of + binary modules. It is not an application on it's own. + + It was fully intended that pthreads-win32 be usable with + commercial software not covered by either the GPL or the LGPL + licenses. Pthreads-win32 has many contributors to it's + code base, many of whom have done so because they have + used the library in commercial or proprietry software + projects. + + Releasing pthreads-win32 under the LGPL ensures that the + library can be used widely, while at the same time ensures + that bug fixes and improvements to the pthreads-win32 code + itself is returned to benefit all current and future users + of the library. + + Although pthreads-win32 makes it possible for applications + that use POSIX threads to be ported to Win32 platforms, the + broader goal of the project is to encourage the use of open + standards, and in particular, to make it just a little easier + for developers writing Win32 applications to consider + widening the potential market for their products. diff --git a/src/external/pthread/include/pthread.h b/src/external/pthread/include/pthread.h new file mode 100644 index 000000000..b4072f72c --- /dev/null +++ b/src/external/pthread/include/pthread.h @@ -0,0 +1,1368 @@ +/* This is an implementation of the threads API of POSIX 1003.1-2001. + * + * -------------------------------------------------------------------------- + * + * Pthreads-win32 - POSIX Threads Library for Win32 + * Copyright(C) 1998 John E. Bossom + * Copyright(C) 1999,2005 Pthreads-win32 contributors + * + * Contact Email: rpj@callisto.canberra.edu.au + * + * The current list of contributors is contained + * in the file CONTRIBUTORS included with the source + * code distribution. The list can also be seen at the + * following World Wide Web location: + * http://sources.redhat.com/pthreads-win32/contributors.html + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library in the file COPYING.LIB; + * if not, write to the Free Software Foundation, Inc., + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + */ + +#if !defined( PTHREAD_H ) +#define PTHREAD_H + +/* + * See the README file for an explanation of the pthreads-win32 version + * numbering scheme and how the DLL is named etc. + */ +#define PTW32_VERSION 2,9,1,0 +#define PTW32_VERSION_STRING "2, 9, 1, 0\0" + +/* There are three implementations of cancel cleanup. + * Note that pthread.h is included in both application + * compilation units and also internally for the library. + * The code here and within the library aims to work + * for all reasonable combinations of environments. + * + * The three implementations are: + * + * WIN32 SEH + * C + * C++ + * + * Please note that exiting a push/pop block via + * "return", "exit", "break", or "continue" will + * lead to different behaviour amongst applications + * depending upon whether the library was built + * using SEH, C++, or C. For example, a library built + * with SEH will call the cleanup routine, while both + * C++ and C built versions will not. + */ + +/* + * Define defaults for cleanup code. + * Note: Unless the build explicitly defines one of the following, then + * we default to standard C style cleanup. This style uses setjmp/longjmp + * in the cancelation and thread exit implementations and therefore won't + * do stack unwinding if linked to applications that have it (e.g. + * C++ apps). This is currently consistent with most/all commercial Unix + * POSIX threads implementations. + */ +#if !defined( __CLEANUP_SEH ) && !defined( __CLEANUP_CXX ) && !defined( __CLEANUP_C ) +# define __CLEANUP_C +#endif + +#if defined( __CLEANUP_SEH ) && ( !defined( _MSC_VER ) && !defined(PTW32_RC_MSC)) +#error ERROR [__FILE__, line __LINE__]: SEH is not supported for this compiler. +#endif + +/* + * Stop here if we are being included by the resource compiler. + */ +#if !defined(RC_INVOKED) + +#undef PTW32_LEVEL + +#if defined(_POSIX_SOURCE) +#define PTW32_LEVEL 0 +/* Early POSIX */ +#endif + +#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309 +#undef PTW32_LEVEL +#define PTW32_LEVEL 1 +/* Include 1b, 1c and 1d */ +#endif + +#if defined(INCLUDE_NP) +#undef PTW32_LEVEL +#define PTW32_LEVEL 2 +/* Include Non-Portable extensions */ +#endif + +#define PTW32_LEVEL_MAX 3 + +#if ( defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112 ) || !defined(PTW32_LEVEL) +#define PTW32_LEVEL PTW32_LEVEL_MAX +/* Include everything */ +#endif + +#if defined(_UWIN) +# define HAVE_STRUCT_TIMESPEC 1 +# define HAVE_SIGNAL_H 1 +# undef HAVE_PTW32_CONFIG_H +# pragma comment(lib, "pthread") +#endif + +/* + * ------------------------------------------------------------- + * + * + * Module: pthread.h + * + * Purpose: + * Provides an implementation of PThreads based upon the + * standard: + * + * POSIX 1003.1-2001 + * and + * The Single Unix Specification version 3 + * + * (these two are equivalent) + * + * in order to enhance code portability between Windows, + * various commercial Unix implementations, and Linux. + * + * See the ANNOUNCE file for a full list of conforming + * routines and defined constants, and a list of missing + * routines and constants not defined in this implementation. + * + * Authors: + * There have been many contributors to this library. + * The initial implementation was contributed by + * John Bossom, and several others have provided major + * sections or revisions of parts of the implementation. + * Often significant effort has been contributed to + * find and fix important bugs and other problems to + * improve the reliability of the library, which sometimes + * is not reflected in the amount of code which changed as + * result. + * As much as possible, the contributors are acknowledged + * in the ChangeLog file in the source code distribution + * where their changes are noted in detail. + * + * Contributors are listed in the CONTRIBUTORS file. + * + * As usual, all bouquets go to the contributors, and all + * brickbats go to the project maintainer. + * + * Maintainer: + * The code base for this project is coordinated and + * eventually pre-tested, packaged, and made available by + * + * Ross Johnson + * + * QA Testers: + * Ultimately, the library is tested in the real world by + * a host of competent and demanding scientists and + * engineers who report bugs and/or provide solutions + * which are then fixed or incorporated into subsequent + * versions of the library. Each time a bug is fixed, a + * test case is written to prove the fix and ensure + * that later changes to the code don't reintroduce the + * same error. The number of test cases is slowly growing + * and therefore so is the code reliability. + * + * Compliance: + * See the file ANNOUNCE for the list of implemented + * and not-implemented routines and defined options. + * Of course, these are all defined is this file as well. + * + * Web site: + * The source code and other information about this library + * are available from + * + * http://sources.redhat.com/pthreads-win32/ + * + * ------------------------------------------------------------- + */ + +/* Try to avoid including windows.h */ +#if (defined(__MINGW64__) || defined(__MINGW32__)) && defined(__cplusplus) +#define PTW32_INCLUDE_WINDOWS_H +#endif + +#if defined(PTW32_INCLUDE_WINDOWS_H) +#include +#endif + +#if defined(_MSC_VER) && _MSC_VER < 1300 || defined(__DMC__) +/* + * VC++6.0 or early compiler's header has no DWORD_PTR type. + */ +typedef unsigned long DWORD_PTR; +typedef unsigned long ULONG_PTR; +#endif +/* + * ----------------- + * autoconf switches + * ----------------- + */ + +#if defined(HAVE_PTW32_CONFIG_H) +#include "config.h" +#endif /* HAVE_PTW32_CONFIG_H */ + +#if !defined(NEED_FTIME) +#include +#else /* NEED_FTIME */ +/* use native WIN32 time API */ +#endif /* NEED_FTIME */ + +#if defined(HAVE_SIGNAL_H) +#include +#endif /* HAVE_SIGNAL_H */ + +#include + +/* + * Boolean values to make us independent of system includes. + */ +enum { + PTW32_FALSE = 0, + PTW32_TRUE = (! PTW32_FALSE) +}; + +/* + * This is a duplicate of what is in the autoconf config.h, + * which is only used when building the pthread-win32 libraries. + */ + +#if !defined(PTW32_CONFIG_H) +# if defined(WINCE) +# define NEED_ERRNO +# define NEED_SEM +# endif +# if defined(__MINGW64__) +# define HAVE_STRUCT_TIMESPEC +# define HAVE_MODE_T +# elif defined(_UWIN) || defined(__MINGW32__) +# define HAVE_MODE_T +# endif +#endif + +/* + * + */ + +#if PTW32_LEVEL >= PTW32_LEVEL_MAX +#if defined(NEED_ERRNO) +#include "need_errno.h" +#else +#include +#endif +#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */ + +/* + * Several systems don't define some error numbers. + */ +#if !defined(ENOTSUP) +# define ENOTSUP 48 /* This is the value in Solaris. */ +#endif + +#if !defined(ETIMEDOUT) +# define ETIMEDOUT 10060 /* Same as WSAETIMEDOUT */ +#endif + +#if !defined(ENOSYS) +# define ENOSYS 140 /* Semi-arbitrary value */ +#endif + +#if !defined(EDEADLK) +# if defined(EDEADLOCK) +# define EDEADLK EDEADLOCK +# else +# define EDEADLK 36 /* This is the value in MSVC. */ +# endif +#endif + +/* POSIX 2008 - related to robust mutexes */ +#if !defined(EOWNERDEAD) +# define EOWNERDEAD 43 +#endif +#if !defined(ENOTRECOVERABLE) +# define ENOTRECOVERABLE 44 +#endif + +#include + +/* + * To avoid including windows.h we define only those things that we + * actually need from it. + */ +#if !defined(PTW32_INCLUDE_WINDOWS_H) +#if !defined(HANDLE) +# define PTW32__HANDLE_DEF +# define HANDLE void * +#endif +#if !defined(DWORD) +# define PTW32__DWORD_DEF +# define DWORD unsigned long +#endif +#endif + +#if !defined(HAVE_STRUCT_TIMESPEC) +#define HAVE_STRUCT_TIMESPEC +#if !defined(_TIMESPEC_DEFINED) +#define _TIMESPEC_DEFINED +struct timespec { + time_t tv_sec; + long tv_nsec; +}; +#endif /* _TIMESPEC_DEFINED */ +#endif /* HAVE_STRUCT_TIMESPEC */ + +#if !defined(SIG_BLOCK) +#define SIG_BLOCK 0 +#endif /* SIG_BLOCK */ + +#if !defined(SIG_UNBLOCK) +#define SIG_UNBLOCK 1 +#endif /* SIG_UNBLOCK */ + +#if !defined(SIG_SETMASK) +#define SIG_SETMASK 2 +#endif /* SIG_SETMASK */ + +#if defined(__cplusplus) +extern "C" +{ +#endif /* __cplusplus */ + +/* + * ------------------------------------------------------------- + * + * POSIX 1003.1-2001 Options + * ========================= + * + * Options are normally set in , which is not provided + * with pthreads-win32. + * + * For conformance with the Single Unix Specification (version 3), all of the + * options below are defined, and have a value of either -1 (not supported) + * or 200112L (supported). + * + * These options can neither be left undefined nor have a value of 0, because + * either indicates that sysconf(), which is not implemented, may be used at + * runtime to check the status of the option. + * + * _POSIX_THREADS (== 200112L) + * If == 200112L, you can use threads + * + * _POSIX_THREAD_ATTR_STACKSIZE (== 200112L) + * If == 200112L, you can control the size of a thread's + * stack + * pthread_attr_getstacksize + * pthread_attr_setstacksize + * + * _POSIX_THREAD_ATTR_STACKADDR (== -1) + * If == 200112L, you can allocate and control a thread's + * stack. If not supported, the following functions + * will return ENOSYS, indicating they are not + * supported: + * pthread_attr_getstackaddr + * pthread_attr_setstackaddr + * + * _POSIX_THREAD_PRIORITY_SCHEDULING (== -1) + * If == 200112L, you can use realtime scheduling. + * This option indicates that the behaviour of some + * implemented functions conforms to the additional TPS + * requirements in the standard. E.g. rwlocks favour + * writers over readers when threads have equal priority. + * + * _POSIX_THREAD_PRIO_INHERIT (== -1) + * If == 200112L, you can create priority inheritance + * mutexes. + * pthread_mutexattr_getprotocol + + * pthread_mutexattr_setprotocol + + * + * _POSIX_THREAD_PRIO_PROTECT (== -1) + * If == 200112L, you can create priority ceiling mutexes + * Indicates the availability of: + * pthread_mutex_getprioceiling + * pthread_mutex_setprioceiling + * pthread_mutexattr_getprioceiling + * pthread_mutexattr_getprotocol + + * pthread_mutexattr_setprioceiling + * pthread_mutexattr_setprotocol + + * + * _POSIX_THREAD_PROCESS_SHARED (== -1) + * If set, you can create mutexes and condition + * variables that can be shared with another + * process.If set, indicates the availability + * of: + * pthread_mutexattr_getpshared + * pthread_mutexattr_setpshared + * pthread_condattr_getpshared + * pthread_condattr_setpshared + * + * _POSIX_THREAD_SAFE_FUNCTIONS (== 200112L) + * If == 200112L you can use the special *_r library + * functions that provide thread-safe behaviour + * + * _POSIX_READER_WRITER_LOCKS (== 200112L) + * If == 200112L, you can use read/write locks + * + * _POSIX_SPIN_LOCKS (== 200112L) + * If == 200112L, you can use spin locks + * + * _POSIX_BARRIERS (== 200112L) + * If == 200112L, you can use barriers + * + * + These functions provide both 'inherit' and/or + * 'protect' protocol, based upon these macro + * settings. + * + * ------------------------------------------------------------- + */ + +/* + * POSIX Options + */ +#undef _POSIX_THREADS +#define _POSIX_THREADS 200809L + +#undef _POSIX_READER_WRITER_LOCKS +#define _POSIX_READER_WRITER_LOCKS 200809L + +#undef _POSIX_SPIN_LOCKS +#define _POSIX_SPIN_LOCKS 200809L + +#undef _POSIX_BARRIERS +#define _POSIX_BARRIERS 200809L + +#undef _POSIX_THREAD_SAFE_FUNCTIONS +#define _POSIX_THREAD_SAFE_FUNCTIONS 200809L + +#undef _POSIX_THREAD_ATTR_STACKSIZE +#define _POSIX_THREAD_ATTR_STACKSIZE 200809L + +/* + * The following options are not supported + */ +#undef _POSIX_THREAD_ATTR_STACKADDR +#define _POSIX_THREAD_ATTR_STACKADDR -1 + +#undef _POSIX_THREAD_PRIO_INHERIT +#define _POSIX_THREAD_PRIO_INHERIT -1 + +#undef _POSIX_THREAD_PRIO_PROTECT +#define _POSIX_THREAD_PRIO_PROTECT -1 + +/* TPS is not fully supported. */ +#undef _POSIX_THREAD_PRIORITY_SCHEDULING +#define _POSIX_THREAD_PRIORITY_SCHEDULING -1 + +#undef _POSIX_THREAD_PROCESS_SHARED +#define _POSIX_THREAD_PROCESS_SHARED -1 + + +/* + * POSIX 1003.1-2001 Limits + * =========================== + * + * These limits are normally set in , which is not provided with + * pthreads-win32. + * + * PTHREAD_DESTRUCTOR_ITERATIONS + * Maximum number of attempts to destroy + * a thread's thread-specific data on + * termination (must be at least 4) + * + * PTHREAD_KEYS_MAX + * Maximum number of thread-specific data keys + * available per process (must be at least 128) + * + * PTHREAD_STACK_MIN + * Minimum supported stack size for a thread + * + * PTHREAD_THREADS_MAX + * Maximum number of threads supported per + * process (must be at least 64). + * + * SEM_NSEMS_MAX + * The maximum number of semaphores a process can have. + * (must be at least 256) + * + * SEM_VALUE_MAX + * The maximum value a semaphore can have. + * (must be at least 32767) + * + */ +#undef _POSIX_THREAD_DESTRUCTOR_ITERATIONS +#define _POSIX_THREAD_DESTRUCTOR_ITERATIONS 4 + +#undef PTHREAD_DESTRUCTOR_ITERATIONS +#define PTHREAD_DESTRUCTOR_ITERATIONS _POSIX_THREAD_DESTRUCTOR_ITERATIONS + +#undef _POSIX_THREAD_KEYS_MAX +#define _POSIX_THREAD_KEYS_MAX 128 + +#undef PTHREAD_KEYS_MAX +#define PTHREAD_KEYS_MAX _POSIX_THREAD_KEYS_MAX + +#undef PTHREAD_STACK_MIN +#define PTHREAD_STACK_MIN 0 + +#undef _POSIX_THREAD_THREADS_MAX +#define _POSIX_THREAD_THREADS_MAX 64 + + /* Arbitrary value */ +#undef PTHREAD_THREADS_MAX +#define PTHREAD_THREADS_MAX 2019 + +#undef _POSIX_SEM_NSEMS_MAX +#define _POSIX_SEM_NSEMS_MAX 256 + + /* Arbitrary value */ +#undef SEM_NSEMS_MAX +#define SEM_NSEMS_MAX 1024 + +#undef _POSIX_SEM_VALUE_MAX +#define _POSIX_SEM_VALUE_MAX 32767 + +#undef SEM_VALUE_MAX +#define SEM_VALUE_MAX INT_MAX + + +#if defined(__GNUC__) && !defined(__declspec) +# error Please upgrade your GNU compiler to one that supports __declspec. +#endif + +/* + * When building the library, you should define PTW32_BUILD so that + * the variables/functions are exported correctly. When using the library, + * do NOT define PTW32_BUILD, and then the variables/functions will + * be imported correctly. + */ +#if !defined(PTW32_STATIC_LIB) +# if defined(PTW32_BUILD) +# define PTW32_DLLPORT __declspec (dllexport) +# else +# define PTW32_DLLPORT __declspec (dllimport) +# endif +#else +# define PTW32_DLLPORT +#endif + +/* + * The Open Watcom C/C++ compiler uses a non-standard calling convention + * that passes function args in registers unless __cdecl is explicitly specified + * in exposed function prototypes. + * + * We force all calls to cdecl even though this could slow Watcom code down + * slightly. If you know that the Watcom compiler will be used to build both + * the DLL and application, then you can probably define this as a null string. + * Remember that pthread.h (this file) is used for both the DLL and application builds. + */ +#define PTW32_CDECL __cdecl + +#if defined(_UWIN) && PTW32_LEVEL >= PTW32_LEVEL_MAX +# include +#else +/* + * Generic handle type - intended to extend uniqueness beyond + * that available with a simple pointer. It should scale for either + * IA-32 or IA-64. + */ +typedef struct { + void * p; /* Pointer to actual object */ + unsigned int x; /* Extra information - reuse count etc */ +} ptw32_handle_t; + +typedef ptw32_handle_t pthread_t; +typedef struct pthread_attr_t_ * pthread_attr_t; +typedef struct pthread_once_t_ pthread_once_t; +typedef struct pthread_key_t_ * pthread_key_t; +typedef struct pthread_mutex_t_ * pthread_mutex_t; +typedef struct pthread_mutexattr_t_ * pthread_mutexattr_t; +typedef struct pthread_cond_t_ * pthread_cond_t; +typedef struct pthread_condattr_t_ * pthread_condattr_t; +#endif +typedef struct pthread_rwlock_t_ * pthread_rwlock_t; +typedef struct pthread_rwlockattr_t_ * pthread_rwlockattr_t; +typedef struct pthread_spinlock_t_ * pthread_spinlock_t; +typedef struct pthread_barrier_t_ * pthread_barrier_t; +typedef struct pthread_barrierattr_t_ * pthread_barrierattr_t; + +/* + * ==================== + * ==================== + * POSIX Threads + * ==================== + * ==================== + */ + +enum { +/* + * pthread_attr_{get,set}detachstate + */ + PTHREAD_CREATE_JOINABLE = 0, /* Default */ + PTHREAD_CREATE_DETACHED = 1, + +/* + * pthread_attr_{get,set}inheritsched + */ + PTHREAD_INHERIT_SCHED = 0, + PTHREAD_EXPLICIT_SCHED = 1, /* Default */ + +/* + * pthread_{get,set}scope + */ + PTHREAD_SCOPE_PROCESS = 0, + PTHREAD_SCOPE_SYSTEM = 1, /* Default */ + +/* + * pthread_setcancelstate paramters + */ + PTHREAD_CANCEL_ENABLE = 0, /* Default */ + PTHREAD_CANCEL_DISABLE = 1, + +/* + * pthread_setcanceltype parameters + */ + PTHREAD_CANCEL_ASYNCHRONOUS = 0, + PTHREAD_CANCEL_DEFERRED = 1, /* Default */ + +/* + * pthread_mutexattr_{get,set}pshared + * pthread_condattr_{get,set}pshared + */ + PTHREAD_PROCESS_PRIVATE = 0, + PTHREAD_PROCESS_SHARED = 1, + +/* + * pthread_mutexattr_{get,set}robust + */ + PTHREAD_MUTEX_STALLED = 0, /* Default */ + PTHREAD_MUTEX_ROBUST = 1, + +/* + * pthread_barrier_wait + */ + PTHREAD_BARRIER_SERIAL_THREAD = -1 +}; + +/* + * ==================== + * ==================== + * Cancelation + * ==================== + * ==================== + */ +#define PTHREAD_CANCELED ((void *)(size_t) -1) + + +/* + * ==================== + * ==================== + * Once Key + * ==================== + * ==================== + */ +#define PTHREAD_ONCE_INIT { PTW32_FALSE, 0, 0, 0} + +struct pthread_once_t_ +{ + int done; /* indicates if user function has been executed */ + void * lock; + int reserved1; + int reserved2; +}; + + +/* + * ==================== + * ==================== + * Object initialisers + * ==================== + * ==================== + */ +#define PTHREAD_MUTEX_INITIALIZER ((pthread_mutex_t)(size_t) -1) +#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER ((pthread_mutex_t)(size_t) -2) +#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER ((pthread_mutex_t)(size_t) -3) + +/* + * Compatibility with LinuxThreads + */ +#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP PTHREAD_RECURSIVE_MUTEX_INITIALIZER +#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP PTHREAD_ERRORCHECK_MUTEX_INITIALIZER + +#define PTHREAD_COND_INITIALIZER ((pthread_cond_t)(size_t) -1) + +#define PTHREAD_RWLOCK_INITIALIZER ((pthread_rwlock_t)(size_t) -1) + +#define PTHREAD_SPINLOCK_INITIALIZER ((pthread_spinlock_t)(size_t) -1) + + +/* + * Mutex types. + */ +enum +{ + /* Compatibility with LinuxThreads */ + PTHREAD_MUTEX_FAST_NP, + PTHREAD_MUTEX_RECURSIVE_NP, + PTHREAD_MUTEX_ERRORCHECK_NP, + PTHREAD_MUTEX_TIMED_NP = PTHREAD_MUTEX_FAST_NP, + PTHREAD_MUTEX_ADAPTIVE_NP = PTHREAD_MUTEX_FAST_NP, + /* For compatibility with POSIX */ + PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_FAST_NP, + PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP, + PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP, + PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL +}; + + +typedef struct ptw32_cleanup_t ptw32_cleanup_t; + +#if defined(_MSC_VER) +/* Disable MSVC 'anachronism used' warning */ +#pragma warning( disable : 4229 ) +#endif + +typedef void (* PTW32_CDECL ptw32_cleanup_callback_t)(void *); + +#if defined(_MSC_VER) +#pragma warning( default : 4229 ) +#endif + +struct ptw32_cleanup_t +{ + ptw32_cleanup_callback_t routine; + void *arg; + struct ptw32_cleanup_t *prev; +}; + +#if defined(__CLEANUP_SEH) + /* + * WIN32 SEH version of cancel cleanup. + */ + +#define pthread_cleanup_push( _rout, _arg ) \ + { \ + ptw32_cleanup_t _cleanup; \ + \ + _cleanup.routine = (ptw32_cleanup_callback_t)(_rout); \ + _cleanup.arg = (_arg); \ + __try \ + { \ + +#define pthread_cleanup_pop( _execute ) \ + } \ + __finally \ + { \ + if( _execute || AbnormalTermination()) \ + { \ + (*(_cleanup.routine))( _cleanup.arg ); \ + } \ + } \ + } + +#else /* __CLEANUP_SEH */ + +#if defined(__CLEANUP_C) + + /* + * C implementation of PThreads cancel cleanup + */ + +#define pthread_cleanup_push( _rout, _arg ) \ + { \ + ptw32_cleanup_t _cleanup; \ + \ + ptw32_push_cleanup( &_cleanup, (ptw32_cleanup_callback_t) (_rout), (_arg) ); \ + +#define pthread_cleanup_pop( _execute ) \ + (void) ptw32_pop_cleanup( _execute ); \ + } + +#else /* __CLEANUP_C */ + +#if defined(__CLEANUP_CXX) + + /* + * C++ version of cancel cleanup. + * - John E. Bossom. + */ + + class PThreadCleanup { + /* + * PThreadCleanup + * + * Purpose + * This class is a C++ helper class that is + * used to implement pthread_cleanup_push/ + * pthread_cleanup_pop. + * The destructor of this class automatically + * pops the pushed cleanup routine regardless + * of how the code exits the scope + * (i.e. such as by an exception) + */ + ptw32_cleanup_callback_t cleanUpRout; + void * obj; + int executeIt; + + public: + PThreadCleanup() : + cleanUpRout( 0 ), + obj( 0 ), + executeIt( 0 ) + /* + * No cleanup performed + */ + { + } + + PThreadCleanup( + ptw32_cleanup_callback_t routine, + void * arg ) : + cleanUpRout( routine ), + obj( arg ), + executeIt( 1 ) + /* + * Registers a cleanup routine for 'arg' + */ + { + } + + ~PThreadCleanup() + { + if ( executeIt && ((void *) cleanUpRout != (void *) 0) ) + { + (void) (*cleanUpRout)( obj ); + } + } + + void execute( int exec ) + { + executeIt = exec; + } + }; + + /* + * C++ implementation of PThreads cancel cleanup; + * This implementation takes advantage of a helper + * class who's destructor automatically calls the + * cleanup routine if we exit our scope weirdly + */ +#define pthread_cleanup_push( _rout, _arg ) \ + { \ + PThreadCleanup cleanup((ptw32_cleanup_callback_t)(_rout), \ + (void *) (_arg) ); + +#define pthread_cleanup_pop( _execute ) \ + cleanup.execute( _execute ); \ + } + +#else + +#error ERROR [__FILE__, line __LINE__]: Cleanup type undefined. + +#endif /* __CLEANUP_CXX */ + +#endif /* __CLEANUP_C */ + +#endif /* __CLEANUP_SEH */ + +/* + * =============== + * =============== + * Methods + * =============== + * =============== + */ + +/* + * PThread Attribute Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_attr_init (pthread_attr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_destroy (pthread_attr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_getdetachstate (const pthread_attr_t * attr, + int *detachstate); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_getstackaddr (const pthread_attr_t * attr, + void **stackaddr); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_getstacksize (const pthread_attr_t * attr, + size_t * stacksize); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_setdetachstate (pthread_attr_t * attr, + int detachstate); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_setstackaddr (pthread_attr_t * attr, + void *stackaddr); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_setstacksize (pthread_attr_t * attr, + size_t stacksize); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_getschedparam (const pthread_attr_t *attr, + struct sched_param *param); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_setschedparam (pthread_attr_t *attr, + const struct sched_param *param); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_setschedpolicy (pthread_attr_t *, + int); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_getschedpolicy (const pthread_attr_t *, + int *); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_setinheritsched(pthread_attr_t * attr, + int inheritsched); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_getinheritsched(const pthread_attr_t * attr, + int * inheritsched); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_setscope (pthread_attr_t *, + int); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_getscope (const pthread_attr_t *, + int *); + +/* + * PThread Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_create (pthread_t * tid, + const pthread_attr_t * attr, + void *(PTW32_CDECL *start) (void *), + void *arg); + +PTW32_DLLPORT int PTW32_CDECL pthread_detach (pthread_t tid); + +PTW32_DLLPORT int PTW32_CDECL pthread_equal (pthread_t t1, + pthread_t t2); + +PTW32_DLLPORT void PTW32_CDECL pthread_exit (void *value_ptr); + +PTW32_DLLPORT int PTW32_CDECL pthread_join (pthread_t thread, + void **value_ptr); + +PTW32_DLLPORT pthread_t PTW32_CDECL pthread_self (void); + +PTW32_DLLPORT int PTW32_CDECL pthread_cancel (pthread_t thread); + +PTW32_DLLPORT int PTW32_CDECL pthread_setcancelstate (int state, + int *oldstate); + +PTW32_DLLPORT int PTW32_CDECL pthread_setcanceltype (int type, + int *oldtype); + +PTW32_DLLPORT void PTW32_CDECL pthread_testcancel (void); + +PTW32_DLLPORT int PTW32_CDECL pthread_once (pthread_once_t * once_control, + void (PTW32_CDECL *init_routine) (void)); + +#if PTW32_LEVEL >= PTW32_LEVEL_MAX +PTW32_DLLPORT ptw32_cleanup_t * PTW32_CDECL ptw32_pop_cleanup (int execute); + +PTW32_DLLPORT void PTW32_CDECL ptw32_push_cleanup (ptw32_cleanup_t * cleanup, + ptw32_cleanup_callback_t routine, + void *arg); +#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */ + +/* + * Thread Specific Data Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_key_create (pthread_key_t * key, + void (PTW32_CDECL *destructor) (void *)); + +PTW32_DLLPORT int PTW32_CDECL pthread_key_delete (pthread_key_t key); + +PTW32_DLLPORT int PTW32_CDECL pthread_setspecific (pthread_key_t key, + const void *value); + +PTW32_DLLPORT void * PTW32_CDECL pthread_getspecific (pthread_key_t key); + + +/* + * Mutex Attribute Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_init (pthread_mutexattr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_destroy (pthread_mutexattr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_getpshared (const pthread_mutexattr_t + * attr, + int *pshared); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_setpshared (pthread_mutexattr_t * attr, + int pshared); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_settype (pthread_mutexattr_t * attr, int kind); +PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_gettype (const pthread_mutexattr_t * attr, int *kind); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_setrobust( + pthread_mutexattr_t *attr, + int robust); +PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_getrobust( + const pthread_mutexattr_t * attr, + int * robust); + +/* + * Barrier Attribute Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_init (pthread_barrierattr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_destroy (pthread_barrierattr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_getpshared (const pthread_barrierattr_t + * attr, + int *pshared); + +PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_setpshared (pthread_barrierattr_t * attr, + int pshared); + +/* + * Mutex Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_mutex_init (pthread_mutex_t * mutex, + const pthread_mutexattr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutex_destroy (pthread_mutex_t * mutex); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutex_lock (pthread_mutex_t * mutex); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutex_timedlock(pthread_mutex_t * mutex, + const struct timespec *abstime); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutex_trylock (pthread_mutex_t * mutex); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutex_unlock (pthread_mutex_t * mutex); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutex_consistent (pthread_mutex_t * mutex); + +/* + * Spinlock Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_spin_init (pthread_spinlock_t * lock, int pshared); + +PTW32_DLLPORT int PTW32_CDECL pthread_spin_destroy (pthread_spinlock_t * lock); + +PTW32_DLLPORT int PTW32_CDECL pthread_spin_lock (pthread_spinlock_t * lock); + +PTW32_DLLPORT int PTW32_CDECL pthread_spin_trylock (pthread_spinlock_t * lock); + +PTW32_DLLPORT int PTW32_CDECL pthread_spin_unlock (pthread_spinlock_t * lock); + +/* + * Barrier Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_barrier_init (pthread_barrier_t * barrier, + const pthread_barrierattr_t * attr, + unsigned int count); + +PTW32_DLLPORT int PTW32_CDECL pthread_barrier_destroy (pthread_barrier_t * barrier); + +PTW32_DLLPORT int PTW32_CDECL pthread_barrier_wait (pthread_barrier_t * barrier); + +/* + * Condition Variable Attribute Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_condattr_init (pthread_condattr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_condattr_destroy (pthread_condattr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_condattr_getpshared (const pthread_condattr_t * attr, + int *pshared); + +PTW32_DLLPORT int PTW32_CDECL pthread_condattr_setpshared (pthread_condattr_t * attr, + int pshared); + +/* + * Condition Variable Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_cond_init (pthread_cond_t * cond, + const pthread_condattr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_cond_destroy (pthread_cond_t * cond); + +PTW32_DLLPORT int PTW32_CDECL pthread_cond_wait (pthread_cond_t * cond, + pthread_mutex_t * mutex); + +PTW32_DLLPORT int PTW32_CDECL pthread_cond_timedwait (pthread_cond_t * cond, + pthread_mutex_t * mutex, + const struct timespec *abstime); + +PTW32_DLLPORT int PTW32_CDECL pthread_cond_signal (pthread_cond_t * cond); + +PTW32_DLLPORT int PTW32_CDECL pthread_cond_broadcast (pthread_cond_t * cond); + +/* + * Scheduling + */ +PTW32_DLLPORT int PTW32_CDECL pthread_setschedparam (pthread_t thread, + int policy, + const struct sched_param *param); + +PTW32_DLLPORT int PTW32_CDECL pthread_getschedparam (pthread_t thread, + int *policy, + struct sched_param *param); + +PTW32_DLLPORT int PTW32_CDECL pthread_setconcurrency (int); + +PTW32_DLLPORT int PTW32_CDECL pthread_getconcurrency (void); + +/* + * Read-Write Lock Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_init(pthread_rwlock_t *lock, + const pthread_rwlockattr_t *attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_destroy(pthread_rwlock_t *lock); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_tryrdlock(pthread_rwlock_t *); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_trywrlock(pthread_rwlock_t *); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_rdlock(pthread_rwlock_t *lock); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_timedrdlock(pthread_rwlock_t *lock, + const struct timespec *abstime); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_wrlock(pthread_rwlock_t *lock); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_timedwrlock(pthread_rwlock_t *lock, + const struct timespec *abstime); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_unlock(pthread_rwlock_t *lock); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_init (pthread_rwlockattr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_destroy (pthread_rwlockattr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * attr, + int *pshared); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_setpshared (pthread_rwlockattr_t * attr, + int pshared); + +#if PTW32_LEVEL >= PTW32_LEVEL_MAX - 1 + +/* + * Signal Functions. Should be defined in but MSVC and MinGW32 + * already have signal.h that don't define these. + */ +PTW32_DLLPORT int PTW32_CDECL pthread_kill(pthread_t thread, int sig); + +/* + * Non-portable functions + */ + +/* + * Compatibility with Linux. + */ +PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_setkind_np(pthread_mutexattr_t * attr, + int kind); +PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_getkind_np(pthread_mutexattr_t * attr, + int *kind); + +/* + * Possibly supported by other POSIX threads implementations + */ +PTW32_DLLPORT int PTW32_CDECL pthread_delay_np (struct timespec * interval); +PTW32_DLLPORT int PTW32_CDECL pthread_num_processors_np(void); +PTW32_DLLPORT unsigned __int64 PTW32_CDECL pthread_getunique_np(pthread_t thread); + +/* + * Useful if an application wants to statically link + * the lib rather than load the DLL at run-time. + */ +PTW32_DLLPORT int PTW32_CDECL pthread_win32_process_attach_np(void); +PTW32_DLLPORT int PTW32_CDECL pthread_win32_process_detach_np(void); +PTW32_DLLPORT int PTW32_CDECL pthread_win32_thread_attach_np(void); +PTW32_DLLPORT int PTW32_CDECL pthread_win32_thread_detach_np(void); + +/* + * Features that are auto-detected at load/run time. + */ +PTW32_DLLPORT int PTW32_CDECL pthread_win32_test_features_np(int); +enum ptw32_features { + PTW32_SYSTEM_INTERLOCKED_COMPARE_EXCHANGE = 0x0001, /* System provides it. */ + PTW32_ALERTABLE_ASYNC_CANCEL = 0x0002 /* Can cancel blocked threads. */ +}; + +/* + * Register a system time change with the library. + * Causes the library to perform various functions + * in response to the change. Should be called whenever + * the application's top level window receives a + * WM_TIMECHANGE message. It can be passed directly to + * pthread_create() as a new thread if desired. + */ +PTW32_DLLPORT void * PTW32_CDECL pthread_timechange_handler_np(void *); + +#endif /*PTW32_LEVEL >= PTW32_LEVEL_MAX - 1 */ + +#if PTW32_LEVEL >= PTW32_LEVEL_MAX + +/* + * Returns the Win32 HANDLE for the POSIX thread. + */ +PTW32_DLLPORT HANDLE PTW32_CDECL pthread_getw32threadhandle_np(pthread_t thread); +/* + * Returns the win32 thread ID for POSIX thread. + */ +PTW32_DLLPORT DWORD PTW32_CDECL pthread_getw32threadid_np (pthread_t thread); + + +/* + * Protected Methods + * + * This function blocks until the given WIN32 handle + * is signaled or pthread_cancel had been called. + * This function allows the caller to hook into the + * PThreads cancel mechanism. It is implemented using + * + * WaitForMultipleObjects + * + * on 'waitHandle' and a manually reset WIN32 Event + * used to implement pthread_cancel. The 'timeout' + * argument to TimedWait is simply passed to + * WaitForMultipleObjects. + */ +PTW32_DLLPORT int PTW32_CDECL pthreadCancelableWait (HANDLE waitHandle); +PTW32_DLLPORT int PTW32_CDECL pthreadCancelableTimedWait (HANDLE waitHandle, + DWORD timeout); + +#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */ + +/* + * Thread-Safe C Runtime Library Mappings. + */ +#if !defined(_UWIN) +# if defined(NEED_ERRNO) + PTW32_DLLPORT int * PTW32_CDECL _errno( void ); +# else +# if !defined(errno) +# if (defined(_MT) || defined(_DLL)) + __declspec(dllimport) extern int * __cdecl _errno(void); +# define errno (*_errno()) +# endif +# endif +# endif +#endif + +/* + * Some compiler environments don't define some things. + */ +#if defined(__BORLANDC__) +# define _ftime ftime +# define _timeb timeb +#endif + +#if defined(__cplusplus) + +/* + * Internal exceptions + */ +class ptw32_exception {}; +class ptw32_exception_cancel : public ptw32_exception {}; +class ptw32_exception_exit : public ptw32_exception {}; + +#endif + +#if PTW32_LEVEL >= PTW32_LEVEL_MAX + +/* FIXME: This is only required if the library was built using SEH */ +/* + * Get internal SEH tag + */ +PTW32_DLLPORT DWORD PTW32_CDECL ptw32_get_exception_services_code(void); + +#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */ + +#if !defined(PTW32_BUILD) + +#if defined(__CLEANUP_SEH) + +/* + * Redefine the SEH __except keyword to ensure that applications + * propagate our internal exceptions up to the library's internal handlers. + */ +#define __except( E ) \ + __except( ( GetExceptionCode() == ptw32_get_exception_services_code() ) \ + ? EXCEPTION_CONTINUE_SEARCH : ( E ) ) + +#endif /* __CLEANUP_SEH */ + +#if defined(__CLEANUP_CXX) + +/* + * Redefine the C++ catch keyword to ensure that applications + * propagate our internal exceptions up to the library's internal handlers. + */ +#if defined(_MSC_VER) + /* + * WARNING: Replace any 'catch( ... )' with 'PtW32CatchAll' + * if you want Pthread-Win32 cancelation and pthread_exit to work. + */ + +#if !defined(PtW32NoCatchWarn) + +#pragma message("Specify \"/DPtW32NoCatchWarn\" compiler flag to skip this message.") +#pragma message("------------------------------------------------------------------") +#pragma message("When compiling applications with MSVC++ and C++ exception handling:") +#pragma message(" Replace any 'catch( ... )' in routines called from POSIX threads") +#pragma message(" with 'PtW32CatchAll' or 'CATCHALL' if you want POSIX thread") +#pragma message(" cancelation and pthread_exit to work. For example:") +#pragma message("") +#pragma message(" #if defined(PtW32CatchAll)") +#pragma message(" PtW32CatchAll") +#pragma message(" #else") +#pragma message(" catch(...)") +#pragma message(" #endif") +#pragma message(" {") +#pragma message(" /* Catchall block processing */") +#pragma message(" }") +#pragma message("------------------------------------------------------------------") + +#endif + +#define PtW32CatchAll \ + catch( ptw32_exception & ) { throw; } \ + catch( ... ) + +#else /* _MSC_VER */ + +#define catch( E ) \ + catch( ptw32_exception & ) { throw; } \ + catch( E ) + +#endif /* _MSC_VER */ + +#endif /* __CLEANUP_CXX */ + +#endif /* ! PTW32_BUILD */ + +#if defined(__cplusplus) +} /* End of extern "C" */ +#endif /* __cplusplus */ + +#if defined(PTW32__HANDLE_DEF) +# undef HANDLE +#endif +#if defined(PTW32__DWORD_DEF) +# undef DWORD +#endif + +#undef PTW32_LEVEL +#undef PTW32_LEVEL_MAX + +#endif /* ! RC_INVOKED */ + +#endif /* PTHREAD_H */ diff --git a/src/external/pthread/include/sched.h b/src/external/pthread/include/sched.h new file mode 100644 index 000000000..f36a97a66 --- /dev/null +++ b/src/external/pthread/include/sched.h @@ -0,0 +1,183 @@ +/* + * Module: sched.h + * + * Purpose: + * Provides an implementation of POSIX realtime extensions + * as defined in + * + * POSIX 1003.1b-1993 (POSIX.1b) + * + * -------------------------------------------------------------------------- + * + * Pthreads-win32 - POSIX Threads Library for Win32 + * Copyright(C) 1998 John E. Bossom + * Copyright(C) 1999,2005 Pthreads-win32 contributors + * + * Contact Email: rpj@callisto.canberra.edu.au + * + * The current list of contributors is contained + * in the file CONTRIBUTORS included with the source + * code distribution. The list can also be seen at the + * following World Wide Web location: + * http://sources.redhat.com/pthreads-win32/contributors.html + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library in the file COPYING.LIB; + * if not, write to the Free Software Foundation, Inc., + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + */ +#if !defined(_SCHED_H) +#define _SCHED_H + +#undef PTW32_SCHED_LEVEL + +#if defined(_POSIX_SOURCE) +#define PTW32_SCHED_LEVEL 0 +/* Early POSIX */ +#endif + +#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309 +#undef PTW32_SCHED_LEVEL +#define PTW32_SCHED_LEVEL 1 +/* Include 1b, 1c and 1d */ +#endif + +#if defined(INCLUDE_NP) +#undef PTW32_SCHED_LEVEL +#define PTW32_SCHED_LEVEL 2 +/* Include Non-Portable extensions */ +#endif + +#define PTW32_SCHED_LEVEL_MAX 3 + +#if ( defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112 ) || !defined(PTW32_SCHED_LEVEL) +#define PTW32_SCHED_LEVEL PTW32_SCHED_LEVEL_MAX +/* Include everything */ +#endif + + +#if defined(__GNUC__) && !defined(__declspec) +# error Please upgrade your GNU compiler to one that supports __declspec. +#endif + +/* + * When building the library, you should define PTW32_BUILD so that + * the variables/functions are exported correctly. When using the library, + * do NOT define PTW32_BUILD, and then the variables/functions will + * be imported correctly. + */ +#if !defined(PTW32_STATIC_LIB) +# if defined(PTW32_BUILD) +# define PTW32_DLLPORT __declspec (dllexport) +# else +# define PTW32_DLLPORT __declspec (dllimport) +# endif +#else +# define PTW32_DLLPORT +#endif + +/* + * This is a duplicate of what is in the autoconf config.h, + * which is only used when building the pthread-win32 libraries. + */ + +#if !defined(PTW32_CONFIG_H) +# if defined(WINCE) +# define NEED_ERRNO +# define NEED_SEM +# endif +# if defined(__MINGW64__) +# define HAVE_STRUCT_TIMESPEC +# define HAVE_MODE_T +# elif defined(_UWIN) || defined(__MINGW32__) +# define HAVE_MODE_T +# endif +#endif + +/* + * + */ + +#if PTW32_SCHED_LEVEL >= PTW32_SCHED_LEVEL_MAX +#if defined(NEED_ERRNO) +#include "need_errno.h" +#else +#include +#endif +#endif /* PTW32_SCHED_LEVEL >= PTW32_SCHED_LEVEL_MAX */ + +#if (defined(__MINGW64__) || defined(__MINGW32__)) || defined(_UWIN) +# if PTW32_SCHED_LEVEL >= PTW32_SCHED_LEVEL_MAX +/* For pid_t */ +# include +/* Required by Unix 98 */ +# include +# else + typedef int pid_t; +# endif +#else + typedef int pid_t; +#endif + +/* Thread scheduling policies */ + +enum { + SCHED_OTHER = 0, + SCHED_FIFO, + SCHED_RR, + SCHED_MIN = SCHED_OTHER, + SCHED_MAX = SCHED_RR +}; + +struct sched_param { + int sched_priority; +}; + +#if defined(__cplusplus) +extern "C" +{ +#endif /* __cplusplus */ + +PTW32_DLLPORT int __cdecl sched_yield (void); + +PTW32_DLLPORT int __cdecl sched_get_priority_min (int policy); + +PTW32_DLLPORT int __cdecl sched_get_priority_max (int policy); + +PTW32_DLLPORT int __cdecl sched_setscheduler (pid_t pid, int policy); + +PTW32_DLLPORT int __cdecl sched_getscheduler (pid_t pid); + +/* + * Note that this macro returns ENOTSUP rather than + * ENOSYS as might be expected. However, returning ENOSYS + * should mean that sched_get_priority_{min,max} are + * not implemented as well as sched_rr_get_interval. + * This is not the case, since we just don't support + * round-robin scheduling. Therefore I have chosen to + * return the same value as sched_setscheduler when + * SCHED_RR is passed to it. + */ +#define sched_rr_get_interval(_pid, _interval) \ + ( errno = ENOTSUP, (int) -1 ) + + +#if defined(__cplusplus) +} /* End of extern "C" */ +#endif /* __cplusplus */ + +#undef PTW32_SCHED_LEVEL +#undef PTW32_SCHED_LEVEL_MAX + +#endif /* !_SCHED_H */ + diff --git a/src/external/pthread/include/semaphore.h b/src/external/pthread/include/semaphore.h new file mode 100644 index 000000000..c6e9407e2 --- /dev/null +++ b/src/external/pthread/include/semaphore.h @@ -0,0 +1,169 @@ +/* + * Module: semaphore.h + * + * Purpose: + * Semaphores aren't actually part of the PThreads standard. + * They are defined by the POSIX Standard: + * + * POSIX 1003.1b-1993 (POSIX.1b) + * + * -------------------------------------------------------------------------- + * + * Pthreads-win32 - POSIX Threads Library for Win32 + * Copyright(C) 1998 John E. Bossom + * Copyright(C) 1999,2005 Pthreads-win32 contributors + * + * Contact Email: rpj@callisto.canberra.edu.au + * + * The current list of contributors is contained + * in the file CONTRIBUTORS included with the source + * code distribution. The list can also be seen at the + * following World Wide Web location: + * http://sources.redhat.com/pthreads-win32/contributors.html + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library in the file COPYING.LIB; + * if not, write to the Free Software Foundation, Inc., + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + */ +#if !defined( SEMAPHORE_H ) +#define SEMAPHORE_H + +#undef PTW32_SEMAPHORE_LEVEL + +#if defined(_POSIX_SOURCE) +#define PTW32_SEMAPHORE_LEVEL 0 +/* Early POSIX */ +#endif + +#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309 +#undef PTW32_SEMAPHORE_LEVEL +#define PTW32_SEMAPHORE_LEVEL 1 +/* Include 1b, 1c and 1d */ +#endif + +#if defined(INCLUDE_NP) +#undef PTW32_SEMAPHORE_LEVEL +#define PTW32_SEMAPHORE_LEVEL 2 +/* Include Non-Portable extensions */ +#endif + +#define PTW32_SEMAPHORE_LEVEL_MAX 3 + +#if !defined(PTW32_SEMAPHORE_LEVEL) +#define PTW32_SEMAPHORE_LEVEL PTW32_SEMAPHORE_LEVEL_MAX +/* Include everything */ +#endif + +#if defined(__GNUC__) && ! defined (__declspec) +# error Please upgrade your GNU compiler to one that supports __declspec. +#endif + +/* + * When building the library, you should define PTW32_BUILD so that + * the variables/functions are exported correctly. When using the library, + * do NOT define PTW32_BUILD, and then the variables/functions will + * be imported correctly. + */ +#if !defined(PTW32_STATIC_LIB) +# if defined(PTW32_BUILD) +# define PTW32_DLLPORT __declspec (dllexport) +# else +# define PTW32_DLLPORT __declspec (dllimport) +# endif +#else +# define PTW32_DLLPORT +#endif + +/* + * This is a duplicate of what is in the autoconf config.h, + * which is only used when building the pthread-win32 libraries. + */ + +#if !defined(PTW32_CONFIG_H) +# if defined(WINCE) +# define NEED_ERRNO +# define NEED_SEM +# endif +# if defined(__MINGW64__) +# define HAVE_STRUCT_TIMESPEC +# define HAVE_MODE_T +# elif defined(_UWIN) || defined(__MINGW32__) +# define HAVE_MODE_T +# endif +#endif + +/* + * + */ + +#if PTW32_SEMAPHORE_LEVEL >= PTW32_SEMAPHORE_LEVEL_MAX +#if defined(NEED_ERRNO) +#include "need_errno.h" +#else +#include +#endif +#endif /* PTW32_SEMAPHORE_LEVEL >= PTW32_SEMAPHORE_LEVEL_MAX */ + +#define _POSIX_SEMAPHORES + +#if defined(__cplusplus) +extern "C" +{ +#endif /* __cplusplus */ + +#if !defined(HAVE_MODE_T) +typedef unsigned int mode_t; +#endif + + +typedef struct sem_t_ * sem_t; + +PTW32_DLLPORT int __cdecl sem_init (sem_t * sem, + int pshared, + unsigned int value); + +PTW32_DLLPORT int __cdecl sem_destroy (sem_t * sem); + +PTW32_DLLPORT int __cdecl sem_trywait (sem_t * sem); + +PTW32_DLLPORT int __cdecl sem_wait (sem_t * sem); + +PTW32_DLLPORT int __cdecl sem_timedwait (sem_t * sem, + const struct timespec * abstime); + +PTW32_DLLPORT int __cdecl sem_post (sem_t * sem); + +PTW32_DLLPORT int __cdecl sem_post_multiple (sem_t * sem, + int count); + +PTW32_DLLPORT int __cdecl sem_open (const char * name, + int oflag, + mode_t mode, + unsigned int value); + +PTW32_DLLPORT int __cdecl sem_close (sem_t * sem); + +PTW32_DLLPORT int __cdecl sem_unlink (const char * name); + +PTW32_DLLPORT int __cdecl sem_getvalue (sem_t * sem, + int * sval); + +#if defined(__cplusplus) +} /* End of extern "C" */ +#endif /* __cplusplus */ + +#undef PTW32_SEMAPHORE_LEVEL +#undef PTW32_SEMAPHORE_LEVEL_MAX + +#endif /* !SEMAPHORE_H */ diff --git a/src/external/pthread/lib/libpthreadGC2.a b/src/external/pthread/lib/libpthreadGC2.a new file mode 100644 index 0000000000000000000000000000000000000000..df211759f80f37494af2d8fcea749957bb51aaa3 GIT binary patch literal 93480 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 WJ=di4{18bM;eA|*8CeDP6b%3ejMyUHiG7JGs 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 D*YY=?