/* Implement the most essential subset of POSIX 1003.1-2008 pthread.h.

   Copyright (C) 2009-2020 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3, or (at your option)

   any later version.

   This program 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 General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, see <https://www.gnu.org/licenses/>.  */

/* Written by Paul Eggert, Glen Lenker, and Bruno Haible.  */

#if __GNUC__ >= 3

@PRAGMA_SYSTEM_HEADER@

#endif

@PRAGMA_COLUMNS@

#if defined _GL_ALREADY_INCLUDING_PTHREAD_H

/* Special invocation convention:

   On Android, we have a sequence of nested includes

   <pthread.h> -> <time.h> -> <sys/time.h> -> <sys/select.h> ->

   <signal.h> -> <pthread.h>.

   In this situation, PTHREAD_COND_INITIALIZER is not yet defined,

   therefore we should not attempt to define PTHREAD_MUTEX_NORMAL etc.  */

#@INCLUDE_NEXT@ @NEXT_PTHREAD_H@

#else

/* Normal invocation convention.  */

#ifndef _@GUARD_PREFIX@_PTHREAD_H_

#if @HAVE_PTHREAD_H@

# define _GL_ALREADY_INCLUDING_PTHREAD_H

/* The include_next requires a split double-inclusion guard.  */

# @INCLUDE_NEXT@ @NEXT_PTHREAD_H@

# undef _GL_ALREADY_INCLUDING_PTHREAD_H

#endif

#ifndef _@GUARD_PREFIX@_PTHREAD_H_

#define _@GUARD_PREFIX@_PTHREAD_H_

#define __need_system_stdlib_h

#include <stdlib.h>

#undef __need_system_stdlib_h

/* The pthreads-win32 <pthread.h> defines a couple of broken macros.  */

#undef asctime_r

#undef ctime_r

#undef gmtime_r

#undef localtime_r

#undef rand_r

#undef strtok_r

#include <errno.h>

#include <sched.h>

#include <sys/types.h>

#include <time.h>

/* The definitions of _GL_FUNCDECL_RPL etc. are copied here.  */

/* The definition of _Noreturn is copied here.  */

/* The definition of _GL_ARG_NONNULL is copied here.  */

/* The definition of _GL_WARN_ON_USE is copied here.  */

/* =========== Thread types and macros =========== */

#if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS

# if @GNULIB_PTHREAD_THREAD@

#  include "windows-thread.h"

#  if @HAVE_PTHREAD_T@

#   define pthread_t rpl_pthread_t

#   define pthread_attr_t rpl_pthread_attr_t

#  endif

#  if !GNULIB_defined_pthread_thread_types

typedef glwthread_thread_t pthread_t;

typedef unsigned int pthread_attr_t;

#   define GNULIB_defined_pthread_thread_types 1

#  endif

# else

#  if @HAVE_PTHREAD_T@

#   define pthread_t rpl_pthread_t

#   define pthread_attr_t rpl_pthread_attr_t

#  endif

#  if !GNULIB_defined_pthread_thread_types

typedef int pthread_t;

typedef unsigned int pthread_attr_t;

#   define GNULIB_defined_pthread_thread_types 1

#  endif

# endif

# undef PTHREAD_CREATE_JOINABLE

# undef PTHREAD_CREATE_DETACHED

# define PTHREAD_CREATE_JOINABLE 0

# define PTHREAD_CREATE_DETACHED 1

#else

# if !@HAVE_PTHREAD_T@

#  if !GNULIB_defined_pthread_thread_types

typedef int pthread_t;

typedef unsigned int pthread_attr_t;

#   define GNULIB_defined_pthread_thread_types 1

#  endif

# endif

# if !@HAVE_PTHREAD_CREATE_DETACHED@

#  define PTHREAD_CREATE_JOINABLE 0

#  define PTHREAD_CREATE_DETACHED 1

# endif

#endif

/* =========== Once-only control (initialization) types and macros ========== */

#if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS

# if @GNULIB_PTHREAD_ONCE@

#  include "windows-once.h"

#  if @HAVE_PTHREAD_T@

#   define pthread_once_t rpl_pthread_once_t

#  endif

#  if !GNULIB_defined_pthread_once_types

typedef glwthread_once_t pthread_once_t;

#   define GNULIB_defined_pthread_once_types 1

#  endif

#  undef PTHREAD_ONCE_INIT

#  define PTHREAD_ONCE_INIT GLWTHREAD_ONCE_INIT

# else

#  if @HAVE_PTHREAD_T@

#   define pthread_once_t rpl_pthread_once_t

#  endif

#  if !GNULIB_defined_pthread_once_types

typedef int pthread_once_t;

#   define GNULIB_defined_pthread_once_types 1

#  endif

#  undef PTHREAD_ONCE_INIT

#  define PTHREAD_ONCE_INIT { 0 }

# endif

#else

# if !@HAVE_PTHREAD_T@

#  if !GNULIB_defined_pthread_once_types

typedef int pthread_once_t;

#   define GNULIB_defined_pthread_once_types 1

#  endif

#  undef PTHREAD_ONCE_INIT

#  define PTHREAD_ONCE_INIT { 0 }

# endif

#endif

/* =========== Mutex types and macros =========== */

#if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS

# if @GNULIB_PTHREAD_MUTEX@

#  include "windows-timedmutex.h"

#  include "windows-timedrecmutex.h"

#  if @HAVE_PTHREAD_T@

#   define pthread_mutex_t rpl_pthread_mutex_t

#   define pthread_mutexattr_t rpl_pthread_mutexattr_t

#  endif

#  if !GNULIB_defined_pthread_mutex_types

typedef struct

        {

          int type;

          union

            {

              glwthread_timedmutex_t    u_timedmutex;

              glwthread_timedrecmutex_t u_timedrecmutex;

            }

          u;

        }

        pthread_mutex_t;

typedef unsigned int pthread_mutexattr_t;

#   define GNULIB_defined_pthread_mutex_types 1

#  endif

#  undef PTHREAD_MUTEX_INITIALIZER

#  define PTHREAD_MUTEX_INITIALIZER { 1, { GLWTHREAD_TIMEDMUTEX_INIT } }

# else

#  if @HAVE_PTHREAD_T@

#   define pthread_mutex_t rpl_pthread_mutex_t

#   define pthread_mutexattr_t rpl_pthread_mutexattr_t

#  endif

#  if !GNULIB_defined_pthread_mutex_types

typedef int pthread_mutex_t;

typedef unsigned int pthread_mutexattr_t;

#   define GNULIB_defined_pthread_mutex_types 1

#  endif

#  undef PTHREAD_MUTEX_INITIALIZER

#  define PTHREAD_MUTEX_INITIALIZER { 0 }

# endif

# undef PTHREAD_MUTEX_DEFAULT

# undef PTHREAD_MUTEX_NORMAL

# undef PTHREAD_MUTEX_ERRORCHECK

# undef PTHREAD_MUTEX_RECURSIVE

# define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL

# define PTHREAD_MUTEX_NORMAL 0

# define PTHREAD_MUTEX_ERRORCHECK 1

# define PTHREAD_MUTEX_RECURSIVE 2

# undef PTHREAD_MUTEX_STALLED

# undef PTHREAD_MUTEX_ROBUST

# define PTHREAD_MUTEX_STALLED 0

# define PTHREAD_MUTEX_ROBUST 1

#else

# if !@HAVE_PTHREAD_T@

#  if !GNULIB_defined_pthread_mutex_types

typedef int pthread_mutex_t;

typedef unsigned int pthread_mutexattr_t;

#   define GNULIB_defined_pthread_mutex_types 1

#  endif

#  undef PTHREAD_MUTEX_INITIALIZER

#  define PTHREAD_MUTEX_INITIALIZER { 0 }

# endif

# if !@HAVE_PTHREAD_MUTEX_RECURSIVE@

#  define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL

#  define PTHREAD_MUTEX_NORMAL 0

#  define PTHREAD_MUTEX_ERRORCHECK 1

#  define PTHREAD_MUTEX_RECURSIVE 2

# endif

# if !@HAVE_PTHREAD_MUTEX_ROBUST@

#  define PTHREAD_MUTEX_STALLED 0

#  define PTHREAD_MUTEX_ROBUST 1

# endif

#endif

/* =========== Read-write lock types and macros =========== */

#if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS

# if @GNULIB_PTHREAD_RWLOCK@

#  include "windows-timedrwlock.h"

#  if @HAVE_PTHREAD_T@

#   define pthread_rwlock_t rpl_pthread_rwlock_t

#   define pthread_rwlockattr_t rpl_pthread_rwlockattr_t

#  endif

#  if !GNULIB_defined_pthread_rwlock_types

typedef glwthread_timedrwlock_t pthread_rwlock_t;

typedef unsigned int pthread_rwlockattr_t;

#   define GNULIB_defined_pthread_rwlock_types 1

#  endif

#  undef PTHREAD_RWLOCK_INITIALIZER

#  define PTHREAD_RWLOCK_INITIALIZER GLWTHREAD_TIMEDRWLOCK_INIT

# else

#  if @HAVE_PTHREAD_T@

#   define pthread_rwlock_t rpl_pthread_rwlock_t

#   define pthread_rwlockattr_t rpl_pthread_rwlockattr_t

#  endif

#  if !GNULIB_defined_pthread_rwlock_types

typedef int pthread_rwlock_t;

typedef unsigned int pthread_rwlockattr_t;

#   define GNULIB_defined_pthread_rwlock_types 1

#  endif

#  undef PTHREAD_RWLOCK_INITIALIZER

#  define PTHREAD_RWLOCK_INITIALIZER { 0 }

# endif

#elif @GNULIB_PTHREAD_RWLOCK@ && @REPLACE_PTHREAD_RWLOCK_INIT@ /* i.e. PTHREAD_RWLOCK_UNIMPLEMENTED */

# if @HAVE_PTHREAD_T@

#  define pthread_rwlock_t rpl_pthread_rwlock_t

#  define pthread_rwlockattr_t rpl_pthread_rwlockattr_t

# endif

# if !GNULIB_defined_pthread_rwlock_types

typedef struct

        {

          pthread_mutex_t lock; /* protects the remaining fields */

          pthread_cond_t waiting_readers; /* waiting readers */

          pthread_cond_t waiting_writers; /* waiting writers */

          unsigned int waiting_writers_count; /* number of waiting writers */

          int runcount; /* number of readers running, or -1 when a writer runs */

        }

        pthread_rwlock_t;

typedef unsigned int pthread_rwlockattr_t;

#  define GNULIB_defined_pthread_rwlock_types 1

# endif

# undef PTHREAD_RWLOCK_INITIALIZER

# define PTHREAD_RWLOCK_INITIALIZER \

   { PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, PTHREAD_COND_INITIALIZER, 0, 0 }

#else

# if @HAVE_PTHREAD_T@

#  if !defined PTHREAD_RWLOCK_INITIALIZER && defined PTHREAD_RWLOCK_INITIALIZER_NP /* z/OS */

#   define PTHREAD_RWLOCK_INITIALIZER PTHREAD_RWLOCK_INITIALIZER_NP

#  endif

# else

#  if !GNULIB_defined_pthread_rwlock_types

typedef int pthread_rwlock_t;

typedef unsigned int pthread_rwlockattr_t;

#   define GNULIB_defined_pthread_rwlock_types 1

#  endif

#  undef PTHREAD_RWLOCK_INITIALIZER

#  define PTHREAD_RWLOCK_INITIALIZER { 0 }

# endif

#endif

/* =========== Condition variable types and macros =========== */

#if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS

# if @GNULIB_PTHREAD_COND@

#  include "windows-cond.h"

#  if @HAVE_PTHREAD_T@

#   define pthread_cond_t rpl_pthread_cond_t

#   define pthread_condattr_t rpl_pthread_condattr_t

#  endif

#  if !GNULIB_defined_pthread_cond_types

typedef glwthread_cond_t pthread_cond_t;

typedef unsigned int pthread_condattr_t;

#   define GNULIB_defined_pthread_cond_types 1

#  endif

#  undef PTHREAD_COND_INITIALIZER

#  define PTHREAD_COND_INITIALIZER GLWTHREAD_COND_INIT

# else

#  if @HAVE_PTHREAD_T@

#   define pthread_cond_t rpl_pthread_cond_t

#   define pthread_condattr_t rpl_pthread_condattr_t

#  endif

#  if !GNULIB_defined_pthread_cond_types

typedef int pthread_cond_t;

typedef unsigned int pthread_condattr_t;

#   define GNULIB_defined_pthread_cond_types 1

#  endif

#  undef PTHREAD_COND_INITIALIZER

#  define PTHREAD_COND_INITIALIZER { 0 }

# endif

#else

# if !@HAVE_PTHREAD_T@

#  if !GNULIB_defined_pthread_cond_types

typedef int pthread_cond_t;

typedef unsigned int pthread_condattr_t;

#   define GNULIB_defined_pthread_cond_types 1

#  endif

#  undef PTHREAD_COND_INITIALIZER

#  define PTHREAD_COND_INITIALIZER { 0 }

# endif

#endif

/* =========== Thread-specific storage types and macros =========== */

#if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS

# if @GNULIB_PTHREAD_TSS@

#  include "windows-tls.h"

#  if @HAVE_PTHREAD_T@

#   define pthread_key_t rpl_pthread_key_t

#  endif

#  if !GNULIB_defined_pthread_tss_types

typedef glwthread_tls_key_t pthread_key_t;

#   define GNULIB_defined_pthread_tss_types 1

#  endif

#  undef PTHREAD_DESTRUCTOR_ITERATIONS

#  define PTHREAD_DESTRUCTOR_ITERATIONS GLWTHREAD_DESTRUCTOR_ITERATIONS

# else

#  if @HAVE_PTHREAD_T@

#   define pthread_key_t rpl_pthread_key_t

#  endif

#  if !GNULIB_defined_pthread_tss_types

typedef void ** pthread_key_t;

#   define GNULIB_defined_pthread_tss_types 1

#  endif

#  undef PTHREAD_DESTRUCTOR_ITERATIONS

#  define PTHREAD_DESTRUCTOR_ITERATIONS 0

# endif

#else

# if !@HAVE_PTHREAD_T@

#  if !GNULIB_defined_pthread_tss_types

typedef void ** pthread_key_t;

#   define GNULIB_defined_pthread_tss_types 1

#  endif

#  undef PTHREAD_DESTRUCTOR_ITERATIONS

#  define PTHREAD_DESTRUCTOR_ITERATIONS 0

# endif

#endif

/* =========== Spinlock types and macros =========== */

#if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS

# if @GNULIB_PTHREAD_SPIN@

#  include "windows-spin.h"

#  if @HAVE_PTHREAD_T@

#   define pthread_spinlock_t rpl_pthread_spinlock_t

#  endif

#  if !GNULIB_defined_pthread_spin_types

typedef glwthread_spinlock_t pthread_spinlock_t;

#   define GNULIB_defined_pthread_spin_types 1

#  endif

# else

#  if @HAVE_PTHREAD_T@

#   define pthread_spinlock_t rpl_pthread_spinlock_t

#  endif

#  if !GNULIB_defined_pthread_spin_types

typedef pthread_mutex_t pthread_spinlock_t;

#   define GNULIB_defined_pthread_spin_types 1

#  endif

# endif

# undef PTHREAD_PROCESS_PRIVATE

# undef PTHREAD_PROCESS_SHARED

# define PTHREAD_PROCESS_PRIVATE 0

# define PTHREAD_PROCESS_SHARED 1

#else

# if !@HAVE_PTHREAD_SPINLOCK_T@

/* Approximate spinlocks with mutexes.  */

#  if !GNULIB_defined_pthread_spin_types

typedef pthread_mutex_t pthread_spinlock_t;

#   define GNULIB_defined_pthread_spin_types 1

#  endif

# endif

# if !@HAVE_PTHREAD_PROCESS_SHARED@

#  define PTHREAD_PROCESS_PRIVATE 0

#  define PTHREAD_PROCESS_SHARED 1

# endif

#endif

/* =========== Other types and macros =========== */

#if !@HAVE_PTHREAD_T@

# if !GNULIB_defined_other_pthread_types

typedef int pthread_barrier_t;

typedef unsigned int pthread_barrierattr_t;

#  define GNULIB_defined_other_pthread_types 1

# endif

#endif

#if !defined PTHREAD_CANCELED

# define PTHREAD_BARRIER_SERIAL_THREAD (-1)

# define PTHREAD_CANCEL_DEFERRED 0

# define PTHREAD_CANCEL_ASYNCHRONOUS 1

# define PTHREAD_CANCEL_ENABLE 0

# define PTHREAD_CANCEL_DISABLE 1

# define PTHREAD_CANCELED ((void *) -1)

# define PTHREAD_INHERIT_SCHED 0

# define PTHREAD_EXPLICIT_SCHED 1

# define PTHREAD_PRIO_NONE 0

# define PTHREAD_PRIO_INHERIT 1

# define PTHREAD_PRIO_PROTECT 2

# define PTHREAD_SCOPE_SYSTEM 0

# define PTHREAD_SCOPE_PROCESS 1

#endif

/* =========== Thread functions =========== */

#if @GNULIB_PTHREAD_THREAD@

/* The 'restrict' qualifier on ARG is nonsense, but POSIX specifies it this way.

   Sigh.  */

# if @REPLACE_PTHREAD_CREATE@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef pthread_create

#   define pthread_create rpl_pthread_create

#  endif

_GL_FUNCDECL_RPL (pthread_create, int,

                  (pthread_t *restrict threadp,

                   const pthread_attr_t *restrict attr,

                   void * (*mainfunc) (void *), void *restrict arg)

                  _GL_ARG_NONNULL ((1, 3)));

_GL_CXXALIAS_RPL (pthread_create, int,

                  (pthread_t *restrict threadp,

                   const pthread_attr_t *restrict attr,

                   void * (*mainfunc) (void *), void *restrict arg));

# else

#  if !@HAVE_PTHREAD_CREATE@

_GL_FUNCDECL_SYS (pthread_create, int,

                  (pthread_t *restrict threadp,

                   const pthread_attr_t *restrict attr,

                   void * (*mainfunc) (void *), void *restrict arg)

                  _GL_ARG_NONNULL ((1, 3)));

#  endif

_GL_CXXALIAS_SYS_CAST (pthread_create, int,

                       (pthread_t *restrict threadp,

                        const pthread_attr_t *restrict attr,

                        void * (*mainfunc) (void *), void *restrict arg));

# endif

_GL_CXXALIASWARN (pthread_create);

#elif defined GNULIB_POSIXCHECK

# undef pthread_create

# if HAVE_RAW_DECL_PTHREAD_CREATE

_GL_WARN_ON_USE (pthread_create, "pthread_create is not portable - "

                 "use gnulib module pthread-thread for portability");

# endif

#endif

#if @GNULIB_PTHREAD_THREAD@

# if @REPLACE_PTHREAD_ATTR_INIT@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef pthread_attr_init

#   define pthread_attr_init rpl_pthread_attr_init

#  endif

_GL_FUNCDECL_RPL (pthread_attr_init, int, (pthread_attr_t *attr)

                                          _GL_ARG_NONNULL ((1)));

_GL_CXXALIAS_RPL (pthread_attr_init, int, (pthread_attr_t *attr));

# else

#  if !@HAVE_PTHREAD_ATTR_INIT@

_GL_FUNCDECL_SYS (pthread_attr_init, int, (pthread_attr_t *attr)

                                          _GL_ARG_NONNULL ((1)));

#  endif

_GL_CXXALIAS_SYS (pthread_attr_init, int, (pthread_attr_t *attr));

# endif

_GL_CXXALIASWARN (pthread_attr_init);

#elif defined GNULIB_POSIXCHECK

# undef pthread_attr_init

# if HAVE_RAW_DECL_PTHREAD_ATTR_INIT

_GL_WARN_ON_USE (pthread_attr_init, "pthread_attr_init is not portable - "

                 "use gnulib module pthread-thread for portability");

# endif

#endif

#if @GNULIB_PTHREAD_THREAD@

# if @REPLACE_PTHREAD_ATTR_GETDETACHSTATE@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef pthread_attr_getdetachstate

#   define pthread_attr_getdetachstate rpl_pthread_attr_getdetachstate

#  endif

_GL_FUNCDECL_RPL (pthread_attr_getdetachstate, int,

                  (const pthread_attr_t *attr, int *detachstatep)

                  _GL_ARG_NONNULL ((1, 2)));

_GL_CXXALIAS_RPL (pthread_attr_getdetachstate, int,

                  (const pthread_attr_t *attr, int *detachstatep));

# else

#  if !@HAVE_PTHREAD_ATTR_GETDETACHSTATE@

_GL_FUNCDECL_SYS (pthread_attr_getdetachstate, int,

                  (const pthread_attr_t *attr, int *detachstatep)

                  _GL_ARG_NONNULL ((1, 2)));

#  endif

_GL_CXXALIAS_SYS (pthread_attr_getdetachstate, int,

                  (const pthread_attr_t *attr, int *detachstatep));

# endif

_GL_CXXALIASWARN (pthread_attr_getdetachstate);

#elif defined GNULIB_POSIXCHECK

# undef pthread_attr_getdetachstate

# if HAVE_RAW_DECL_PTHREAD_ATTR_GETDETACHSTATE

_GL_WARN_ON_USE (pthread_attr_getdetachstate, "pthread_attr_getdetachstate is not portable - "

                 "use gnulib module pthread-thread for portability");

# endif

#endif

#if @GNULIB_PTHREAD_THREAD@

# if @REPLACE_PTHREAD_ATTR_SETDETACHSTATE@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef pthread_attr_setdetachstate

#   define pthread_attr_setdetachstate rpl_pthread_attr_setdetachstate

#  endif

_GL_FUNCDECL_RPL (pthread_attr_setdetachstate, int,

                  (pthread_attr_t *attr, int detachstate)

                  _GL_ARG_NONNULL ((1)));

_GL_CXXALIAS_RPL (pthread_attr_setdetachstate, int,

                  (pthread_attr_t *attr, int detachstate));

# else

#  if !@HAVE_PTHREAD_ATTR_SETDETACHSTATE@

_GL_FUNCDECL_SYS (pthread_attr_setdetachstate, int,

                  (pthread_attr_t *attr, int detachstate)

                  _GL_ARG_NONNULL ((1)));

#  endif

_GL_CXXALIAS_SYS (pthread_attr_setdetachstate, int,

                  (pthread_attr_t *attr, int detachstate));

# endif

_GL_CXXALIASWARN (pthread_attr_setdetachstate);

#elif defined GNULIB_POSIXCHECK

# undef pthread_attr_setdetachstate

# if HAVE_RAW_DECL_PTHREAD_ATTR_SETDETACHSTATE

_GL_WARN_ON_USE (pthread_attr_setdetachstate, "pthread_attr_setdetachstate is not portable - "

                 "use gnulib module pthread-thread for portability");

# endif

#endif

#if @GNULIB_PTHREAD_THREAD@

# if @REPLACE_PTHREAD_ATTR_DESTROY@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef pthread_attr_destroy

#   define pthread_attr_destroy rpl_pthread_attr_destroy

#  endif

_GL_FUNCDECL_RPL (pthread_attr_destroy, int, (pthread_attr_t *attr)

                                             _GL_ARG_NONNULL ((1)));

_GL_CXXALIAS_RPL (pthread_attr_destroy, int, (pthread_attr_t *attr));

# else

#  if !@HAVE_PTHREAD_ATTR_DESTROY@

_GL_FUNCDECL_SYS (pthread_attr_destroy, int, (pthread_attr_t *attr)

                                             _GL_ARG_NONNULL ((1)));

#  endif

_GL_CXXALIAS_SYS (pthread_attr_destroy, int, (pthread_attr_t *attr));

# endif

_GL_CXXALIASWARN (pthread_attr_destroy);

#elif defined GNULIB_POSIXCHECK

# undef pthread_attr_destroy

# if HAVE_RAW_DECL_PTHREAD_ATTR_DESTROY

_GL_WARN_ON_USE (pthread_attr_destroy, "pthread_attr_destroy is not portable - "

                 "use gnulib module pthread-thread for portability");

# endif

#endif

#if @GNULIB_PTHREAD_THREAD@

# if @REPLACE_PTHREAD_SELF@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef pthread_self

#   define pthread_self rpl_pthread_self

#  endif

_GL_FUNCDECL_RPL (pthread_self, pthread_t, (void) _GL_ATTRIBUTE_PURE);

_GL_CXXALIAS_RPL (pthread_self, pthread_t, (void));

# else

#  if !@HAVE_PTHREAD_SELF@

_GL_FUNCDECL_SYS (pthread_self, pthread_t, (void) _GL_ATTRIBUTE_PURE);

#  endif

_GL_CXXALIAS_SYS (pthread_self, pthread_t, (void));

# endif

_GL_CXXALIASWARN (pthread_self);

#elif defined GNULIB_POSIXCHECK

# undef pthread_self

# if HAVE_RAW_DECL_PTHREAD_SELF

_GL_WARN_ON_USE (pthread_self, "pthread_self is not portable - "

                 "use gnulib module pthread-thread for portability");

# endif

#endif

#if @GNULIB_PTHREAD_THREAD@

# if @REPLACE_PTHREAD_EQUAL@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef pthread_equal

#   define pthread_equal rpl_pthread_equal

#  endif

_GL_FUNCDECL_RPL (pthread_equal, int, (pthread_t thread1, pthread_t thread2));

_GL_CXXALIAS_RPL (pthread_equal, int, (pthread_t thread1, pthread_t thread2));

# else

#  if !@HAVE_PTHREAD_EQUAL@

_GL_FUNCDECL_SYS (pthread_equal, int, (pthread_t thread1, pthread_t thread2));

#  endif

_GL_CXXALIAS_SYS (pthread_equal, int, (pthread_t thread1, pthread_t thread2));

# endif

_GL_CXXALIASWARN (pthread_equal);

#elif defined GNULIB_POSIXCHECK

# undef pthread_equal

# if HAVE_RAW_DECL_PTHREAD_EQUAL

_GL_WARN_ON_USE (pthread_equal, "pthread_equal is not portable - "

                 "use gnulib module pthread-thread for portability");

# endif

#endif

#if @GNULIB_PTHREAD_THREAD@

# if @REPLACE_PTHREAD_DETACH@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef pthread_detach

#   define pthread_detach rpl_pthread_detach

#  endif

_GL_FUNCDECL_RPL (pthread_detach, int, (pthread_t thread));

_GL_CXXALIAS_RPL (pthread_detach, int, (pthread_t thread));

# else

#  if !@HAVE_PTHREAD_DETACH@

_GL_FUNCDECL_SYS (pthread_detach, int, (pthread_t thread));

#  endif

_GL_CXXALIAS_SYS (pthread_detach, int, (pthread_t thread));

# endif

_GL_CXXALIASWARN (pthread_detach);

#elif defined GNULIB_POSIXCHECK

# undef pthread_detach

# if HAVE_RAW_DECL_PTHREAD_DETACH

_GL_WARN_ON_USE (pthread_detach, "pthread_detach is not portable - "

                 "use gnulib module pthread-thread for portability");

# endif

#endif

#if @GNULIB_PTHREAD_THREAD@

# if @REPLACE_PTHREAD_JOIN@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef pthread_join

#   define pthread_join rpl_pthread_join

#  endif

_GL_FUNCDECL_RPL (pthread_join, int, (pthread_t thread, void **valuep));

_GL_CXXALIAS_RPL (pthread_join, int, (pthread_t thread, void **valuep));

# else

#  if !@HAVE_PTHREAD_JOIN@

_GL_FUNCDECL_SYS (pthread_join, int, (pthread_t thread, void **valuep));

#  endif

_GL_CXXALIAS_SYS (pthread_join, int, (pthread_t thread, void **valuep));

# endif

_GL_CXXALIASWARN (pthread_join);

#elif defined GNULIB_POSIXCHECK

# undef pthread_join

# if HAVE_RAW_DECL_PTHREAD_JOIN

_GL_WARN_ON_USE (pthread_join, "pthread_join is not portable - "

                 "use gnulib module pthread-thread for portability");

# endif

#endif

#if @GNULIB_PTHREAD_THREAD@

# if @REPLACE_PTHREAD_EXIT@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef pthread_exit

#   define pthread_exit rpl_pthread_exit

#  endif

_GL_FUNCDECL_RPL (pthread_exit, _Noreturn void, (void *value));

_GL_CXXALIAS_RPL (pthread_exit, void, (void *value));

# else

#  if !@HAVE_PTHREAD_EXIT@

_GL_FUNCDECL_SYS (pthread_exit, _Noreturn void, (void *value));

#  endif

/* Need to cast because of AIX with xlclang++.  */

_GL_CXXALIAS_SYS_CAST (pthread_exit, void, (void *value));

# endif

_GL_CXXALIASWARN (pthread_exit);

#elif defined GNULIB_POSIXCHECK

# undef pthread_exit

# if HAVE_RAW_DECL_PTHREAD_EXIT

_GL_WARN_ON_USE (pthread_exit, "pthread_exit is not portable - "

                 "use gnulib module pthread-thread for portability");

# endif

#endif

/* =========== Once-only control (initialization) functions =========== */

#if @GNULIB_PTHREAD_ONCE@

# if @REPLACE_PTHREAD_ONCE@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef pthread_once

#   define pthread_once rpl_pthread_once

#  endif

_GL_FUNCDECL_RPL (pthread_once, int,

                  (pthread_once_t *once_control, void (*initfunction) (void))

                  _GL_ARG_NONNULL ((1, 2)));

_GL_CXXALIAS_RPL (pthread_once, int,

                  (pthread_once_t *once_control, void (*initfunction) (void)));

# else

#  if !@HAVE_PTHREAD_ONCE@

_GL_FUNCDECL_SYS (pthread_once, int,

                  (pthread_once_t *once_control, void (*initfunction) (void))

                   _GL_ARG_NONNULL ((1, 2)));

#  endif

_GL_CXXALIAS_SYS_CAST (pthread_once, int,

                       (pthread_once_t *once_control,

                        void (*initfunction) (void)));

# endif

_GL_CXXALIASWARN (pthread_once);

#elif defined GNULIB_POSIXCHECK

# undef pthread_once

# if HAVE_RAW_DECL_PTHREAD_ONCE

_GL_WARN_ON_USE (pthread_once, "pthread_once is not portable - "

                 "use gnulib module pthread-once for portability");

# endif

#endif

/* =========== Mutex functions =========== */

#if @GNULIB_PTHREAD_MUTEX@

# if @REPLACE_PTHREAD_MUTEX_INIT@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef pthread_mutex_init

#   define pthread_mutex_init rpl_pthread_mutex_init

#  endif

_GL_FUNCDECL_RPL (pthread_mutex_init, int,

                  (pthread_mutex_t *restrict mutex,

                   const pthread_mutexattr_t *restrict attr)

                  _GL_ARG_NONNULL ((1)));

_GL_CXXALIAS_RPL (pthread_mutex_init, int,

                  (pthread_mutex_t *restrict mutex,

                   const pthread_mutexattr_t *restrict attr));

# else

#  if !@HAVE_PTHREAD_MUTEX_INIT@

_GL_FUNCDECL_SYS (pthread_mutex_init, int,

                  (pthread_mutex_t *restrict mutex,

                   const pthread_mutexattr_t *restrict attr)

                  _GL_ARG_NONNULL ((1)));

#  endif

_GL_CXXALIAS_SYS (pthread_mutex_init, int,

                  (pthread_mutex_t *restrict mutex,

                   const pthread_mutexattr_t *restrict attr));

# endif

_GL_CXXALIASWARN (pthread_mutex_init);

#elif defined GNULIB_POSIXCHECK

# undef pthread_mutex_init

# if HAVE_RAW_DECL_PTHREAD_MUTEX_INIT

_GL_WARN_ON_USE (pthread_mutex_init, "pthread_mutex_init is not portable - "

                 "use gnulib module pthread-mutex for portability");

# endif

#endif

#if @GNULIB_PTHREAD_MUTEX@

# if @REPLACE_PTHREAD_MUTEXATTR_INIT@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef pthread_mutexattr_init

#   define pthread_mutexattr_init rpl_pthread_mutexattr_init

#  endif

_GL_FUNCDECL_RPL (pthread_mutexattr_init, int, (pthread_mutexattr_t *attr)

                                               _GL_ARG_NONNULL ((1)));

_GL_CXXALIAS_RPL (pthread_mutexattr_init, int, (pthread_mutexattr_t *attr));

# else

#  if !@HAVE_PTHREAD_MUTEXATTR_INIT@

_GL_FUNCDECL_SYS (pthread_mutexattr_init, int, (pthread_mutexattr_t *attr)

                                               _GL_ARG_NONNULL ((1)));

#  endif

_GL_CXXALIAS_SYS (pthread_mutexattr_init, int, (pthread_mutexattr_t *attr));

# endif

_GL_CXXALIASWARN (pthread_mutexattr_init);

#elif defined GNULIB_POSIXCHECK

# undef pthread_mutexattr_init

# if HAVE_RAW_DECL_PTHREAD_MUTEXATTR_INIT

_GL_WARN_ON_USE (pthread_mutexattr_init, "pthread_mutexattr_init is not portable - "

                 "use gnulib module pthread-mutex for portability");

# endif

#endif

#if @GNULIB_PTHREAD_MUTEX@

# if @REPLACE_PTHREAD_MUTEXATTR_GETTYPE@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef pthread_mutexattr_gettype

#   define pthread_mutexattr_gettype rpl_pthread_mutexattr_gettype

#  endif

_GL_FUNCDECL_RPL (pthread_mutexattr_gettype, int,

                  (const pthread_mutexattr_t *restrict attr,

                   int *restrict typep)

                  _GL_ARG_NONNULL ((1, 2)));

_GL_CXXALIAS_RPL (pthread_mutexattr_gettype, int,

                  (const pthread_mutexattr_t *restrict attr,

                   int *restrict typep));

# else

#  if !@HAVE_PTHREAD_MUTEXATTR_GETTYPE@

_GL_FUNCDECL_SYS (pthread_mutexattr_gettype, int,

                  (const pthread_mutexattr_t *restrict attr,

                   int *restrict typep)

                  _GL_ARG_NONNULL ((1, 2)));

#  endif

/* Need to cast, because on FreeBSD the first parameter is

                        pthread_mutexattr_t *attr.  */

_GL_CXXALIAS_SYS_CAST (pthread_mutexattr_gettype, int,

                       (const pthread_mutexattr_t *restrict attr,

                        int *restrict typep));

# endif

_GL_CXXALIASWARN (pthread_mutexattr_gettype);

#elif defined GNULIB_POSIXCHECK

# undef pthread_mutexattr_gettype

# if HAVE_RAW_DECL_PTHREAD_MUTEXATTR_GETTYPE

_GL_WARN_ON_USE (pthread_mutexattr_gettype, "pthread_mutexattr_gettype is not portable - "

                 "use gnulib module pthread-mutex for portability");

# endif

#endif

#if @GNULIB_PTHREAD_MUTEX@

# if @REPLACE_PTHREAD_MUTEXATTR_SETTYPE@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef pthread_mutexattr_settype

#   define pthread_mutexattr_settype rpl_pthread_mutexattr_settype

#  endif

_GL_FUNCDECL_RPL (pthread_mutexattr_settype, int,

                  (pthread_mutexattr_t *attr, int type) _GL_ARG_NONNULL ((1)));

_GL_CXXALIAS_RPL (pthread_mutexattr_settype, int,

                  (pthread_mutexattr_t *attr, int type));

# else

#  if !@HAVE_PTHREAD_MUTEXATTR_SETTYPE@

_GL_FUNCDECL_SYS (pthread_mutexattr_settype, int,

                  (pthread_mutexattr_t *attr, int type) _GL_ARG_NONNULL ((1)));

#  endif

_GL_CXXALIAS_SYS (pthread_mutexattr_settype, int,

                  (pthread_mutexattr_t *attr, int type));

# endif

_GL_CXXALIASWARN (pthread_mutexattr_settype);

#elif defined GNULIB_POSIXCHECK

# undef pthread_mutexattr_settype

# if HAVE_RAW_DECL_PTHREAD_MUTEXATTR_SETTYPE

_GL_WARN_ON_USE (pthread_mutexattr_settype, "pthread_mutexattr_settype is not portable - "

                 "use gnulib module pthread-mutex for portability");

# endif

#endif

#if @GNULIB_PTHREAD_MUTEX@

# if @REPLACE_PTHREAD_MUTEXATTR_GETROBUST@

#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

#   undef pthread_mutexattr_getrobust

#   define pthread_mutexattr_getrobust rpl_pthread_mutexattr_getrobust

#  endif

_GL_FUNCDECL_RPL (pthread_mutexattr_getrobust, int,

                  (const pthread_mutexattr_t *restrict attr,

                   int *restrict robustp)

                  _GL_ARG_NONNULL ((1, 2)));

_GL_CXXALIAS_RPL (pthread_mutexattr_getrobust, int,

                  (const pthread_mutexattr_t *restrict attr,

                   int *restrict robustp));