From 1394914e768907d22d796e396641803c14349acc Mon Sep 17 00:00:00 2001 From: Dhruva Krishnamurthy Date: Mon, 1 Dec 2008 18:20:39 +0530 Subject: [PATCH] Adding pthread files --- mingw/bin/pthreadGC2.dll | Bin 0 -> 60273 bytes mingw/include/pthread.h | 1368 +++++++++++++++++++++++++++++++++++++++++++++ mingw/include/sched.h | 178 ++++++ mingw/include/semaphore.h | 166 ++++++ mingw/include/setjmp.h | 56 ++ mingw/lib/libpthread.a | Bin 0 -> 89608 bytes 6 files changed, 1768 insertions(+) create mode 100644 mingw/bin/pthreadGC2.dll create mode 100644 mingw/include/pthread.h create mode 100644 mingw/include/sched.h create mode 100644 mingw/include/semaphore.h create mode 100644 mingw/include/setjmp.h create mode 100644 mingw/lib/libpthread.a diff --git a/mingw/bin/pthreadGC2.dll b/mingw/bin/pthreadGC2.dll new file mode 100644 index 0000000000000000000000000000000000000000..8b9116c78e6dec086dd179f86c944c9b9fbcdc89 GIT binary patch literal 60273 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 literal 0 HcwPel00001 diff --git a/mingw/include/pthread.h b/mingw/include/pthread.h new file mode 100644 index 0000000000..9f2868bccb --- /dev/null +++ b/mingw/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,8,0,0 +#define PTW32_VERSION_STRING "2, 8, 0, 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. + */ +#ifndef 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(PTW32_LEVEL) +#define PTW32_LEVEL PTW32_LEVEL_MAX +/* Include everything */ +#endif + +#ifdef _UWIN +# define HAVE_STRUCT_TIMESPEC 1 +# define HAVE_SIGNAL_H 1 +# undef HAVE_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(__MINGW32__) && defined(__cplusplus) +#define PTW32_INCLUDE_WINDOWS_H +#endif + +#ifdef 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; +#endif +/* + * ----------------- + * autoconf switches + * ----------------- + */ + +#if HAVE_CONFIG_H +#include "config.h" +#endif /* HAVE_CONFIG_H */ + +#ifndef NEED_FTIME +#include +#else /* NEED_FTIME */ +/* use native WIN32 time API */ +#endif /* NEED_FTIME */ + +#if HAVE_SIGNAL_H +#include +#endif /* HAVE_SIGNAL_H */ + +#include +#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. + */ + +#ifndef PTW32_CONFIG_H +# if defined(WINCE) +# define NEED_ERRNO +# define NEED_SEM +# endif +# if defined(_UWIN) || defined(__MINGW32__) +# define HAVE_MODE_T +# endif +#endif + +/* + * + */ + +#if PTW32_LEVEL >= PTW32_LEVEL_MAX +#ifdef NEED_ERRNO +#include "need_errno.h" +#else +#include +#endif +#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */ + +/* + * Several systems don't define some error numbers. + */ +#ifndef ENOTSUP +# define ENOTSUP 48 /* This is the value in Solaris. */ +#endif + +#ifndef ETIMEDOUT +# define ETIMEDOUT 10060 /* This is the value in winsock.h. */ +#endif + +#ifndef ENOSYS +# define ENOSYS 140 /* Semi-arbitrary value */ +#endif + +#ifndef EDEADLK +# ifdef EDEADLOCK +# define EDEADLK EDEADLOCK +# else +# define EDEADLK 36 /* This is the value in MSVC. */ +# endif +#endif + +#include + +/* + * To avoid including windows.h we define only those things that we + * actually need from it. + */ +#ifndef PTW32_INCLUDE_WINDOWS_H +#ifndef HANDLE +# define PTW32__HANDLE_DEF +# define HANDLE void * +#endif +#ifndef DWORD +# define PTW32__DWORD_DEF +# define DWORD unsigned long +#endif +#endif + +#ifndef HAVE_STRUCT_TIMESPEC +#define HAVE_STRUCT_TIMESPEC 1 +struct timespec { + long tv_sec; + long tv_nsec; +}; +#endif /* HAVE_STRUCT_TIMESPEC */ + +#ifndef SIG_BLOCK +#define SIG_BLOCK 0 +#endif /* SIG_BLOCK */ + +#ifndef SIG_UNBLOCK +#define SIG_UNBLOCK 1 +#endif /* SIG_UNBLOCK */ + +#ifndef SIG_SETMASK +#define SIG_SETMASK 2 +#endif /* SIG_SETMASK */ + +#ifdef __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 200112L + +#undef _POSIX_READER_WRITER_LOCKS +#define _POSIX_READER_WRITER_LOCKS 200112L + +#undef _POSIX_SPIN_LOCKS +#define _POSIX_SPIN_LOCKS 200112L + +#undef _POSIX_BARRIERS +#define _POSIX_BARRIERS 200112L + +#undef _POSIX_THREAD_SAFE_FUNCTIONS +#define _POSIX_THREAD_SAFE_FUNCTIONS 200112L + +#undef _POSIX_THREAD_ATTR_STACKSIZE +#define _POSIX_THREAD_ATTR_STACKSIZE 200112L + +/* + * 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 __GNUC__ && ! defined (__declspec) +# error Please upgrade your GNU compiler to one that supports __declspec. +#endif + +/* + * When building the DLL code, you should define PTW32_BUILD so that + * the variables/functions are exported correctly. When using the DLL, + * do NOT define PTW32_BUILD, and then the variables/functions will + * be imported correctly. + */ +#ifndef PTW32_STATIC_LIB +# ifdef 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_barrier_wait + */ + PTHREAD_BARRIER_SERIAL_THREAD = -1 +}; + +/* + * ==================== + * ==================== + * Cancelation + * ==================== + * ==================== + */ +#define PTHREAD_CANCELED ((void *) -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) -1) +#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER ((pthread_mutex_t) -2) +#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER ((pthread_mutex_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) -1) + +#define PTHREAD_RWLOCK_INITIALIZER ((pthread_rwlock_t) -1) + +#define PTHREAD_SPINLOCK_INITIALIZER ((pthread_spinlock_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; +}; + +#ifdef __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 */ + +#ifdef __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 */ + +#ifdef __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 (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(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 *(*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 (*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, + void (*routine) (void *), + 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 (*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 (pthread_mutexattr_t * attr, int *kind); + +/* + * 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); + +/* + * 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); + +/* + * 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); + + +/* + * 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. + */ +#ifndef _UWIN +# if defined(NEED_ERRNO) + PTW32_DLLPORT int * PTW32_CDECL _errno( void ); +# else +# ifndef errno +# if (defined(_MT) || defined(_DLL)) + __declspec(dllimport) extern int * __cdecl _errno(void); +# define errno (*_errno()) +# endif +# endif +# endif +#endif + +/* + * WIN32 C runtime library had been made thread-safe + * without affecting the user interface. Provide + * mappings from the UNIX thread-safe versions to + * the standard C runtime library calls. + * Only provide function mappings for functions that + * actually exist on WIN32. + */ + +#if !defined(__MINGW32__) +#define strtok_r( _s, _sep, _lasts ) \ + ( *(_lasts) = strtok( (_s), (_sep) ) ) +#endif /* !__MINGW32__ */ + +#define asctime_r( _tm, _buf ) \ + ( strcpy( (_buf), asctime( (_tm) ) ), \ + (_buf) ) + +#define ctime_r( _clock, _buf ) \ + ( strcpy( (_buf), ctime( (_clock) ) ), \ + (_buf) ) + +#define gmtime_r( _clock, _result ) \ + ( *(_result) = *gmtime( (_clock) ), \ + (_result) ) + +#define localtime_r( _clock, _result ) \ + ( *(_result) = *localtime( (_clock) ), \ + (_result) ) + +#define rand_r( _seed ) \ + ( _seed == _seed? rand() : rand() ) + + +/* + * Some compiler environments don't define some things. + */ +#if defined(__BORLANDC__) +# define _ftime ftime +# define _timeb timeb +#endif + +#ifdef __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 */ + +#ifndef PTW32_BUILD + +#ifdef __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 */ + +#ifdef __CLEANUP_CXX + +/* + * Redefine the C++ catch keyword to ensure that applications + * propagate our internal exceptions up to the library's internal handlers. + */ +#ifdef _MSC_VER + /* + * WARNING: Replace any 'catch( ... )' with 'PtW32CatchAll' + * if you want Pthread-Win32 cancelation and pthread_exit to work. + */ + +#ifndef 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(" #ifdef 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 */ + +#ifdef __cplusplus +} /* End of extern "C" */ +#endif /* __cplusplus */ + +#ifdef PTW32__HANDLE_DEF +# undef HANDLE +#endif +#ifdef PTW32__DWORD_DEF +# undef DWORD +#endif + +#undef PTW32_LEVEL +#undef PTW32_LEVEL_MAX + +#endif /* ! RC_INVOKED */ + +#endif /* PTHREAD_H */ diff --git a/mingw/include/sched.h b/mingw/include/sched.h new file mode 100644 index 0000000000..10ecb5d7ea --- /dev/null +++ b/mingw/include/sched.h @@ -0,0 +1,178 @@ +/* + * 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 + */ +#ifndef _SCHED_H +#define _SCHED_H + +#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(PTW32_LEVEL) +#define PTW32_LEVEL PTW32_LEVEL_MAX +/* Include everything */ +#endif + + +#if __GNUC__ && ! defined (__declspec) +# error Please upgrade your GNU compiler to one that supports __declspec. +#endif + +/* + * When building the DLL code, you should define PTW32_BUILD so that + * the variables/functions are exported correctly. When using the DLL, + * do NOT define PTW32_BUILD, and then the variables/functions will + * be imported correctly. + */ +#ifndef PTW32_STATIC_LIB +# ifdef 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. + */ + +#ifndef PTW32_CONFIG_H +# if defined(WINCE) +# define NEED_ERRNO +# define NEED_SEM +# endif +# if defined(_UWIN) || defined(__MINGW32__) +# define HAVE_MODE_T +# endif +#endif + +/* + * + */ + +#if PTW32_LEVEL >= PTW32_LEVEL_MAX +#ifdef NEED_ERRNO +#include "need_errno.h" +#else +#include +#endif +#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */ + +#if defined(__MINGW32__) || defined(_UWIN) +#if PTW32_LEVEL >= PTW32_LEVEL_MAX +/* For pid_t */ +# include +/* Required by Unix 98 */ +# include +#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */ +#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; +}; + +#ifdef __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 ) + + +#ifdef __cplusplus +} /* End of extern "C" */ +#endif /* __cplusplus */ + +#undef PTW32_LEVEL +#undef PTW32_LEVEL_MAX + +#endif /* !_SCHED_H */ + diff --git a/mingw/include/semaphore.h b/mingw/include/semaphore.h new file mode 100644 index 0000000000..ea42ce3703 --- /dev/null +++ b/mingw/include/semaphore.h @@ -0,0 +1,166 @@ +/* + * 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_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(PTW32_LEVEL) +#define PTW32_LEVEL PTW32_LEVEL_MAX +/* Include everything */ +#endif + +#if __GNUC__ && ! defined (__declspec) +# error Please upgrade your GNU compiler to one that supports __declspec. +#endif + +/* + * When building the DLL code, you should define PTW32_BUILD so that + * the variables/functions are exported correctly. When using the DLL, + * do NOT define PTW32_BUILD, and then the variables/functions will + * be imported correctly. + */ +#ifndef PTW32_STATIC_LIB +# ifdef 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. + */ + +#ifndef PTW32_CONFIG_H +# if defined(WINCE) +# define NEED_ERRNO +# define NEED_SEM +# endif +# if defined(_UWIN) || defined(__MINGW32__) +# define HAVE_MODE_T +# endif +#endif + +/* + * + */ + +#if PTW32_LEVEL >= PTW32_LEVEL_MAX +#ifdef NEED_ERRNO +#include "need_errno.h" +#else +#include +#endif +#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */ + +#define _POSIX_SEMAPHORES + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +#ifndef 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); + +#ifdef __cplusplus +} /* End of extern "C" */ +#endif /* __cplusplus */ + +#undef PTW32_LEVEL +#undef PTW32_LEVEL_MAX + +#endif /* !SEMAPHORE_H */ diff --git a/mingw/include/setjmp.h b/mingw/include/setjmp.h new file mode 100644 index 0000000000..b9e4d6c489 --- /dev/null +++ b/mingw/include/setjmp.h @@ -0,0 +1,56 @@ +/* + * setjmp.h + * This file has no copyright assigned and is placed in the Public Domain. + * This file is a part of the mingw-runtime package. + * No warranty is given; refer to the file DISCLAIMER within the package. + * + * Declarations supporting setjmp and longjump, a method for avoiding + * the normal function call return sequence. (Bleah!) + * + */ + +#ifndef _SETJMP_H_ +#define _SETJMP_H_ + +/* All the headers include this file. */ +#include <_mingw.h> + +#ifndef RC_INVOKED + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * The buffer used by setjmp to store the information used by longjmp + * to perform it's evil goto-like work. The size of this buffer was + * determined through experimentation; it's contents are a mystery. + * NOTE: This was determined on an i386 (actually a Pentium). The + * contents could be different on an Alpha or something else. + */ +#define _JBLEN 16 +#define _JBTYPE int +typedef _JBTYPE jmp_buf[_JBLEN]; + +/* + * The function provided by CRTDLL which appears to do the actual work + * of setjmp. + */ +int __cdecl _setjmp (jmp_buf); + +#define setjmp(x) _setjmp(x) + +/* + * Return to the last setjmp call and act as if setjmp had returned + * nVal (which had better be non-zero!). + */ +void __cdecl longjmp (jmp_buf, int); + +#ifdef __cplusplus +} +#endif + +#endif /* Not RC_INVOKED */ + +#endif /* Not _SETJMP_H_ */ + diff --git a/mingw/lib/libpthread.a b/mingw/lib/libpthread.a new file mode 100644 index 0000000000000000000000000000000000000000..07b4d8c9f01fd28f408db850faf3ac73a3589388 GIT binary patch literal 89608 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 CUo8ay literal 0 HcwPel00001 -- 2.11.4.GIT