VirtualBox

source: kBuild/vendor/grep/current/gnulib-tests/pthread.in.h

Last change on this file was 3529, checked in by bird, 3 years ago

Imported grep 3.7 from grep-3.7.tar.gz (sha256: c22b0cf2d4f6bbe599c902387e8058990e1eee99aef333a203829e5fd3dbb342), applying minimal auto-props.
  • Property svn:eol-style set to native
File size: 69.2 KB
Line 
1/* Implement the most essential subset of POSIX 1003.1-2008 pthread.h.
2
3 Copyright (C) 2009-2021 Free Software Foundation, Inc.
4
5 This file is free software: you can redistribute it and/or modify
6 it under the terms of the GNU Lesser General Public License as
7 published by the Free Software Foundation; either version 2.1 of the
8 License, or (at your option) any later version.
9
10 This file is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public License
16 along with this program. If not, see <https://www.gnu.org/licenses/>. */
17
18/* Written by Paul Eggert, Glen Lenker, and Bruno Haible. */
19
20#if __GNUC__ >= 3
21@PRAGMA_SYSTEM_HEADER@
22#endif
23@PRAGMA_COLUMNS@
24
25#if defined _GL_ALREADY_INCLUDING_PTHREAD_H
26/* Special invocation convention:
27 On Android, we have a sequence of nested includes
28 <pthread.h> -> <time.h> -> <sys/time.h> -> <sys/select.h> ->
29 <signal.h> -> <pthread.h>.
30 In this situation, PTHREAD_COND_INITIALIZER is not yet defined,
31 therefore we should not attempt to define PTHREAD_MUTEX_NORMAL etc. */
32
33#@INCLUDE_NEXT@ @NEXT_PTHREAD_H@
34
35#else
36/* Normal invocation convention. */
37
38#ifndef _@GUARD_PREFIX@_PTHREAD_H_
39
40#if @HAVE_PTHREAD_H@
41
42# define _GL_ALREADY_INCLUDING_PTHREAD_H
43
44/* The include_next requires a split double-inclusion guard. */
45# @INCLUDE_NEXT@ @NEXT_PTHREAD_H@
46
47# undef _GL_ALREADY_INCLUDING_PTHREAD_H
48
49#endif
50
51#ifndef _@GUARD_PREFIX@_PTHREAD_H_
52#define _@GUARD_PREFIX@_PTHREAD_H_
53
54#define __need_system_stdlib_h
55#include <stdlib.h>
56#undef __need_system_stdlib_h
57
58
59/* The pthreads-win32 <pthread.h> defines a couple of broken macros. */
60#undef asctime_r
61#undef ctime_r
62#undef gmtime_r
63#undef localtime_r
64#undef rand_r
65#undef strtok_r
66
67#include <errno.h>
68#include <sched.h>
69#include <sys/types.h>
70#include <time.h>
71
72/* The definitions of _GL_FUNCDECL_RPL etc. are copied here. */
73
74/* The definition of _Noreturn is copied here. */
75
76/* The definition of _GL_ARG_NONNULL is copied here. */
77
78/* The definition of _GL_WARN_ON_USE is copied here. */
79
80/* =========== Thread types and macros =========== */
81
82#if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS
83# if @GNULIB_PTHREAD_THREAD@
84# include "windows-thread.h"
85# if @HAVE_PTHREAD_T@
86# define pthread_t rpl_pthread_t
87# define pthread_attr_t rpl_pthread_attr_t
88# endif
89# if !GNULIB_defined_pthread_thread_types
90typedef glwthread_thread_t pthread_t;
91typedef unsigned int pthread_attr_t;
92# define GNULIB_defined_pthread_thread_types 1
93# endif
94# else
95# if @HAVE_PTHREAD_T@
96# define pthread_t rpl_pthread_t
97# define pthread_attr_t rpl_pthread_attr_t
98# endif
99# if !GNULIB_defined_pthread_thread_types
100typedef int pthread_t;
101typedef unsigned int pthread_attr_t;
102# define GNULIB_defined_pthread_thread_types 1
103# endif
104# endif
105# undef PTHREAD_CREATE_JOINABLE
106# undef PTHREAD_CREATE_DETACHED
107# define PTHREAD_CREATE_JOINABLE 0
108# define PTHREAD_CREATE_DETACHED 1
109#else
110# if !@HAVE_PTHREAD_T@
111# if !GNULIB_defined_pthread_thread_types
112typedef int pthread_t;
113typedef unsigned int pthread_attr_t;
114# define GNULIB_defined_pthread_thread_types 1
115# endif
116# endif
117# if !@HAVE_PTHREAD_CREATE_DETACHED@
118# define PTHREAD_CREATE_JOINABLE 0
119# define PTHREAD_CREATE_DETACHED 1
120# endif
121#endif
122
123/* =========== Once-only control (initialization) types and macros ========== */
124
125#if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS
126# if @GNULIB_PTHREAD_ONCE@
127# include "windows-once.h"
128# if @HAVE_PTHREAD_T@
129# define pthread_once_t rpl_pthread_once_t
130# endif
131# if !GNULIB_defined_pthread_once_types
132typedef glwthread_once_t pthread_once_t;
133# define GNULIB_defined_pthread_once_types 1
134# endif
135# undef PTHREAD_ONCE_INIT
136# define PTHREAD_ONCE_INIT GLWTHREAD_ONCE_INIT
137# else
138# if @HAVE_PTHREAD_T@
139# define pthread_once_t rpl_pthread_once_t
140# endif
141# if !GNULIB_defined_pthread_once_types
142typedef int pthread_once_t;
143# define GNULIB_defined_pthread_once_types 1
144# endif
145# undef PTHREAD_ONCE_INIT
146# define PTHREAD_ONCE_INIT { 0 }
147# endif
148#else
149# if !@HAVE_PTHREAD_T@
150# if !GNULIB_defined_pthread_once_types
151typedef int pthread_once_t;
152# define GNULIB_defined_pthread_once_types 1
153# endif
154# undef PTHREAD_ONCE_INIT
155# define PTHREAD_ONCE_INIT { 0 }
156# endif
157#endif
158
159/* =========== Mutex types and macros =========== */
160
161#if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS
162# if @GNULIB_PTHREAD_MUTEX@
163# include "windows-timedmutex.h"
164# include "windows-timedrecmutex.h"
165# if @HAVE_PTHREAD_T@
166# define pthread_mutex_t rpl_pthread_mutex_t
167# define pthread_mutexattr_t rpl_pthread_mutexattr_t
168# endif
169# if !GNULIB_defined_pthread_mutex_types
170typedef struct
171 {
172 int type;
173 union
174 {
175 glwthread_timedmutex_t u_timedmutex;
176 glwthread_timedrecmutex_t u_timedrecmutex;
177 }
178 u;
179 }
180 pthread_mutex_t;
181typedef unsigned int pthread_mutexattr_t;
182# define GNULIB_defined_pthread_mutex_types 1
183# endif
184# undef PTHREAD_MUTEX_INITIALIZER
185# define PTHREAD_MUTEX_INITIALIZER { 1, { GLWTHREAD_TIMEDMUTEX_INIT } }
186# else
187# if @HAVE_PTHREAD_T@
188# define pthread_mutex_t rpl_pthread_mutex_t
189# define pthread_mutexattr_t rpl_pthread_mutexattr_t
190# endif
191# if !GNULIB_defined_pthread_mutex_types
192typedef int pthread_mutex_t;
193typedef unsigned int pthread_mutexattr_t;
194# define GNULIB_defined_pthread_mutex_types 1
195# endif
196# undef PTHREAD_MUTEX_INITIALIZER
197# define PTHREAD_MUTEX_INITIALIZER { 0 }
198# endif
199# undef PTHREAD_MUTEX_DEFAULT
200# undef PTHREAD_MUTEX_NORMAL
201# undef PTHREAD_MUTEX_ERRORCHECK
202# undef PTHREAD_MUTEX_RECURSIVE
203# define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL
204# define PTHREAD_MUTEX_NORMAL 0
205# define PTHREAD_MUTEX_ERRORCHECK 1
206# define PTHREAD_MUTEX_RECURSIVE 2
207# undef PTHREAD_MUTEX_STALLED
208# undef PTHREAD_MUTEX_ROBUST
209# define PTHREAD_MUTEX_STALLED 0
210# define PTHREAD_MUTEX_ROBUST 1
211#else
212# if !@HAVE_PTHREAD_T@
213# if !GNULIB_defined_pthread_mutex_types
214typedef int pthread_mutex_t;
215typedef unsigned int pthread_mutexattr_t;
216# define GNULIB_defined_pthread_mutex_types 1
217# endif
218# undef PTHREAD_MUTEX_INITIALIZER
219# define PTHREAD_MUTEX_INITIALIZER { 0 }
220# endif
221# if !@HAVE_PTHREAD_MUTEX_RECURSIVE@
222# define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL
223# define PTHREAD_MUTEX_NORMAL 0
224# define PTHREAD_MUTEX_ERRORCHECK 1
225# define PTHREAD_MUTEX_RECURSIVE 2
226# endif
227# if !@HAVE_PTHREAD_MUTEX_ROBUST@
228# define PTHREAD_MUTEX_STALLED 0
229# define PTHREAD_MUTEX_ROBUST 1
230# endif
231#endif
232
233/* =========== Read-write lock types and macros =========== */
234
235#if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS
236# if @GNULIB_PTHREAD_RWLOCK@
237# include "windows-timedrwlock.h"
238# if @HAVE_PTHREAD_T@
239# define pthread_rwlock_t rpl_pthread_rwlock_t
240# define pthread_rwlockattr_t rpl_pthread_rwlockattr_t
241# endif
242# if !GNULIB_defined_pthread_rwlock_types
243typedef glwthread_timedrwlock_t pthread_rwlock_t;
244typedef unsigned int pthread_rwlockattr_t;
245# define GNULIB_defined_pthread_rwlock_types 1
246# endif
247# undef PTHREAD_RWLOCK_INITIALIZER
248# define PTHREAD_RWLOCK_INITIALIZER GLWTHREAD_TIMEDRWLOCK_INIT
249# else
250# if @HAVE_PTHREAD_T@
251# define pthread_rwlock_t rpl_pthread_rwlock_t
252# define pthread_rwlockattr_t rpl_pthread_rwlockattr_t
253# endif
254# if !GNULIB_defined_pthread_rwlock_types
255typedef int pthread_rwlock_t;
256typedef unsigned int pthread_rwlockattr_t;
257# define GNULIB_defined_pthread_rwlock_types 1
258# endif
259# undef PTHREAD_RWLOCK_INITIALIZER
260# define PTHREAD_RWLOCK_INITIALIZER { 0 }
261# endif
262#elif @GNULIB_PTHREAD_RWLOCK@ && @REPLACE_PTHREAD_RWLOCK_INIT@ /* i.e. PTHREAD_RWLOCK_UNIMPLEMENTED */
263# if @HAVE_PTHREAD_T@
264# define pthread_rwlock_t rpl_pthread_rwlock_t
265# define pthread_rwlockattr_t rpl_pthread_rwlockattr_t
266# endif
267# if !GNULIB_defined_pthread_rwlock_types
268typedef struct
269 {
270 pthread_mutex_t lock; /* protects the remaining fields */
271 pthread_cond_t waiting_readers; /* waiting readers */
272 pthread_cond_t waiting_writers; /* waiting writers */
273 unsigned int waiting_writers_count; /* number of waiting writers */
274 int runcount; /* number of readers running, or -1 when a writer runs */
275 }
276 pthread_rwlock_t;
277typedef unsigned int pthread_rwlockattr_t;
278# define GNULIB_defined_pthread_rwlock_types 1
279# endif
280# undef PTHREAD_RWLOCK_INITIALIZER
281# define PTHREAD_RWLOCK_INITIALIZER \
282 { PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, PTHREAD_COND_INITIALIZER, 0, 0 }
283#else
284# if @HAVE_PTHREAD_T@
285# if !defined PTHREAD_RWLOCK_INITIALIZER && defined PTHREAD_RWLOCK_INITIALIZER_NP /* z/OS */
286# define PTHREAD_RWLOCK_INITIALIZER PTHREAD_RWLOCK_INITIALIZER_NP
287# endif
288# else
289# if !GNULIB_defined_pthread_rwlock_types
290typedef int pthread_rwlock_t;
291typedef unsigned int pthread_rwlockattr_t;
292# define GNULIB_defined_pthread_rwlock_types 1
293# endif
294# undef PTHREAD_RWLOCK_INITIALIZER
295# define PTHREAD_RWLOCK_INITIALIZER { 0 }
296# endif
297#endif
298
299/* =========== Condition variable types and macros =========== */
300
301#if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS
302# if @GNULIB_PTHREAD_COND@
303# include "windows-cond.h"
304# if @HAVE_PTHREAD_T@
305# define pthread_cond_t rpl_pthread_cond_t
306# define pthread_condattr_t rpl_pthread_condattr_t
307# endif
308# if !GNULIB_defined_pthread_cond_types
309typedef glwthread_cond_t pthread_cond_t;
310typedef unsigned int pthread_condattr_t;
311# define GNULIB_defined_pthread_cond_types 1
312# endif
313# undef PTHREAD_COND_INITIALIZER
314# define PTHREAD_COND_INITIALIZER GLWTHREAD_COND_INIT
315# else
316# if @HAVE_PTHREAD_T@
317# define pthread_cond_t rpl_pthread_cond_t
318# define pthread_condattr_t rpl_pthread_condattr_t
319# endif
320# if !GNULIB_defined_pthread_cond_types
321typedef int pthread_cond_t;
322typedef unsigned int pthread_condattr_t;
323# define GNULIB_defined_pthread_cond_types 1
324# endif
325# undef PTHREAD_COND_INITIALIZER
326# define PTHREAD_COND_INITIALIZER { 0 }
327# endif
328#else
329# if !@HAVE_PTHREAD_T@
330# if !GNULIB_defined_pthread_cond_types
331typedef int pthread_cond_t;
332typedef unsigned int pthread_condattr_t;
333# define GNULIB_defined_pthread_cond_types 1
334# endif
335# undef PTHREAD_COND_INITIALIZER
336# define PTHREAD_COND_INITIALIZER { 0 }
337# endif
338#endif
339
340/* =========== Thread-specific storage types and macros =========== */
341
342#if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS
343# if @GNULIB_PTHREAD_TSS@
344# include "windows-tls.h"
345# if @HAVE_PTHREAD_T@
346# define pthread_key_t rpl_pthread_key_t
347# endif
348# if !GNULIB_defined_pthread_tss_types
349typedef glwthread_tls_key_t pthread_key_t;
350# define GNULIB_defined_pthread_tss_types 1
351# endif
352# undef PTHREAD_DESTRUCTOR_ITERATIONS
353# define PTHREAD_DESTRUCTOR_ITERATIONS GLWTHREAD_DESTRUCTOR_ITERATIONS
354# else
355# if @HAVE_PTHREAD_T@
356# define pthread_key_t rpl_pthread_key_t
357# endif
358# if !GNULIB_defined_pthread_tss_types
359typedef void ** pthread_key_t;
360# define GNULIB_defined_pthread_tss_types 1
361# endif
362# undef PTHREAD_DESTRUCTOR_ITERATIONS
363# define PTHREAD_DESTRUCTOR_ITERATIONS 0
364# endif
365#else
366# if !@HAVE_PTHREAD_T@
367# if !GNULIB_defined_pthread_tss_types
368typedef void ** pthread_key_t;
369# define GNULIB_defined_pthread_tss_types 1
370# endif
371# undef PTHREAD_DESTRUCTOR_ITERATIONS
372# define PTHREAD_DESTRUCTOR_ITERATIONS 0
373# endif
374#endif
375
376/* =========== Spinlock types and macros =========== */
377
378#if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS
379# if @GNULIB_PTHREAD_SPIN@
380# include "windows-spin.h"
381# if @HAVE_PTHREAD_T@
382# define pthread_spinlock_t rpl_pthread_spinlock_t
383# endif
384# if !GNULIB_defined_pthread_spin_types
385typedef glwthread_spinlock_t pthread_spinlock_t;
386# define GNULIB_defined_pthread_spin_types 1
387# endif
388# else
389# if @HAVE_PTHREAD_T@
390# define pthread_spinlock_t rpl_pthread_spinlock_t
391# endif
392# if !GNULIB_defined_pthread_spin_types
393typedef pthread_mutex_t pthread_spinlock_t;
394# define GNULIB_defined_pthread_spin_types 1
395# endif
396# endif
397# undef PTHREAD_PROCESS_PRIVATE
398# undef PTHREAD_PROCESS_SHARED
399# define PTHREAD_PROCESS_PRIVATE 0
400# define PTHREAD_PROCESS_SHARED 1
401#else
402# if !@HAVE_PTHREAD_SPINLOCK_T@
403/* Approximate spinlocks with mutexes. */
404# if !GNULIB_defined_pthread_spin_types
405typedef pthread_mutex_t pthread_spinlock_t;
406# define GNULIB_defined_pthread_spin_types 1
407# endif
408# endif
409# if !@HAVE_PTHREAD_PROCESS_SHARED@
410# define PTHREAD_PROCESS_PRIVATE 0
411# define PTHREAD_PROCESS_SHARED 1
412# endif
413#endif
414
415/* =========== Other types and macros =========== */
416
417#if !@HAVE_PTHREAD_T@
418# if !GNULIB_defined_other_pthread_types
419typedef int pthread_barrier_t;
420typedef unsigned int pthread_barrierattr_t;
421# define GNULIB_defined_other_pthread_types 1
422# endif
423#endif
424
425#if !defined PTHREAD_CANCELED
426
427# define PTHREAD_BARRIER_SERIAL_THREAD (-1)
428
429# define PTHREAD_CANCEL_DEFERRED 0
430# define PTHREAD_CANCEL_ASYNCHRONOUS 1
431
432# define PTHREAD_CANCEL_ENABLE 0
433# define PTHREAD_CANCEL_DISABLE 1
434
435# define PTHREAD_CANCELED ((void *) -1)
436
437# define PTHREAD_INHERIT_SCHED 0
438# define PTHREAD_EXPLICIT_SCHED 1
439
440# define PTHREAD_PRIO_NONE 0
441# define PTHREAD_PRIO_INHERIT 1
442# define PTHREAD_PRIO_PROTECT 2
443
444# define PTHREAD_SCOPE_SYSTEM 0
445# define PTHREAD_SCOPE_PROCESS 1
446
447#endif
448
449/* =========== Thread functions =========== */
450
451#if @GNULIB_PTHREAD_THREAD@
452/* The 'restrict' qualifier on ARG is nonsense, but POSIX specifies it this way.
453 Sigh. */
454# if @REPLACE_PTHREAD_CREATE@
455# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
456# undef pthread_create
457# define pthread_create rpl_pthread_create
458# endif
459_GL_FUNCDECL_RPL (pthread_create, int,
460 (pthread_t *restrict threadp,
461 const pthread_attr_t *restrict attr,
462 void * (*mainfunc) (void *), void *restrict arg)
463 _GL_ARG_NONNULL ((1, 3)));
464_GL_CXXALIAS_RPL (pthread_create, int,
465 (pthread_t *restrict threadp,
466 const pthread_attr_t *restrict attr,
467 void * (*mainfunc) (void *), void *restrict arg));
468# else
469# if !@HAVE_PTHREAD_CREATE@
470_GL_FUNCDECL_SYS (pthread_create, int,
471 (pthread_t *restrict threadp,
472 const pthread_attr_t *restrict attr,
473 void * (*mainfunc) (void *), void *restrict arg)
474 _GL_ARG_NONNULL ((1, 3)));
475# endif
476_GL_CXXALIAS_SYS_CAST (pthread_create, int,
477 (pthread_t *restrict threadp,
478 const pthread_attr_t *restrict attr,
479 void * (*mainfunc) (void *), void *restrict arg));
480# endif
481# if __GLIBC__ >= 2
482_GL_CXXALIASWARN (pthread_create);
483# endif
484#elif defined GNULIB_POSIXCHECK
485# undef pthread_create
486# if HAVE_RAW_DECL_PTHREAD_CREATE
487_GL_WARN_ON_USE (pthread_create, "pthread_create is not portable - "
488 "use gnulib module pthread-thread for portability");
489# endif
490#endif
491
492#if @GNULIB_PTHREAD_THREAD@
493# if @REPLACE_PTHREAD_ATTR_INIT@
494# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
495# undef pthread_attr_init
496# define pthread_attr_init rpl_pthread_attr_init
497# endif
498_GL_FUNCDECL_RPL (pthread_attr_init, int, (pthread_attr_t *attr)
499 _GL_ARG_NONNULL ((1)));
500_GL_CXXALIAS_RPL (pthread_attr_init, int, (pthread_attr_t *attr));
501# else
502# if !@HAVE_PTHREAD_ATTR_INIT@
503_GL_FUNCDECL_SYS (pthread_attr_init, int, (pthread_attr_t *attr)
504 _GL_ARG_NONNULL ((1)));
505# endif
506_GL_CXXALIAS_SYS (pthread_attr_init, int, (pthread_attr_t *attr));
507# endif
508# if __GLIBC__ >= 2
509_GL_CXXALIASWARN (pthread_attr_init);
510# endif
511#elif defined GNULIB_POSIXCHECK
512# undef pthread_attr_init
513# if HAVE_RAW_DECL_PTHREAD_ATTR_INIT
514_GL_WARN_ON_USE (pthread_attr_init, "pthread_attr_init is not portable - "
515 "use gnulib module pthread-thread for portability");
516# endif
517#endif
518
519#if @GNULIB_PTHREAD_THREAD@
520# if @REPLACE_PTHREAD_ATTR_GETDETACHSTATE@
521# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
522# undef pthread_attr_getdetachstate
523# define pthread_attr_getdetachstate rpl_pthread_attr_getdetachstate
524# endif
525_GL_FUNCDECL_RPL (pthread_attr_getdetachstate, int,
526 (const pthread_attr_t *attr, int *detachstatep)
527 _GL_ARG_NONNULL ((1, 2)));
528_GL_CXXALIAS_RPL (pthread_attr_getdetachstate, int,
529 (const pthread_attr_t *attr, int *detachstatep));
530# else
531# if !@HAVE_PTHREAD_ATTR_GETDETACHSTATE@
532_GL_FUNCDECL_SYS (pthread_attr_getdetachstate, int,
533 (const pthread_attr_t *attr, int *detachstatep)
534 _GL_ARG_NONNULL ((1, 2)));
535# endif
536_GL_CXXALIAS_SYS (pthread_attr_getdetachstate, int,
537 (const pthread_attr_t *attr, int *detachstatep));
538# endif
539# if __GLIBC__ >= 2
540_GL_CXXALIASWARN (pthread_attr_getdetachstate);
541# endif
542#elif defined GNULIB_POSIXCHECK
543# undef pthread_attr_getdetachstate
544# if HAVE_RAW_DECL_PTHREAD_ATTR_GETDETACHSTATE
545_GL_WARN_ON_USE (pthread_attr_getdetachstate, "pthread_attr_getdetachstate is not portable - "
546 "use gnulib module pthread-thread for portability");
547# endif
548#endif
549
550#if @GNULIB_PTHREAD_THREAD@
551# if @REPLACE_PTHREAD_ATTR_SETDETACHSTATE@
552# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
553# undef pthread_attr_setdetachstate
554# define pthread_attr_setdetachstate rpl_pthread_attr_setdetachstate
555# endif
556_GL_FUNCDECL_RPL (pthread_attr_setdetachstate, int,
557 (pthread_attr_t *attr, int detachstate)
558 _GL_ARG_NONNULL ((1)));
559_GL_CXXALIAS_RPL (pthread_attr_setdetachstate, int,
560 (pthread_attr_t *attr, int detachstate));
561# else
562# if !@HAVE_PTHREAD_ATTR_SETDETACHSTATE@
563_GL_FUNCDECL_SYS (pthread_attr_setdetachstate, int,
564 (pthread_attr_t *attr, int detachstate)
565 _GL_ARG_NONNULL ((1)));
566# endif
567_GL_CXXALIAS_SYS (pthread_attr_setdetachstate, int,
568 (pthread_attr_t *attr, int detachstate));
569# endif
570# if __GLIBC__ >= 2
571_GL_CXXALIASWARN (pthread_attr_setdetachstate);
572# endif
573#elif defined GNULIB_POSIXCHECK
574# undef pthread_attr_setdetachstate
575# if HAVE_RAW_DECL_PTHREAD_ATTR_SETDETACHSTATE
576_GL_WARN_ON_USE (pthread_attr_setdetachstate, "pthread_attr_setdetachstate is not portable - "
577 "use gnulib module pthread-thread for portability");
578# endif
579#endif
580
581#if @GNULIB_PTHREAD_THREAD@
582# if @REPLACE_PTHREAD_ATTR_DESTROY@
583# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
584# undef pthread_attr_destroy
585# define pthread_attr_destroy rpl_pthread_attr_destroy
586# endif
587_GL_FUNCDECL_RPL (pthread_attr_destroy, int, (pthread_attr_t *attr)
588 _GL_ARG_NONNULL ((1)));
589_GL_CXXALIAS_RPL (pthread_attr_destroy, int, (pthread_attr_t *attr));
590# else
591# if !@HAVE_PTHREAD_ATTR_DESTROY@
592_GL_FUNCDECL_SYS (pthread_attr_destroy, int, (pthread_attr_t *attr)
593 _GL_ARG_NONNULL ((1)));
594# endif
595_GL_CXXALIAS_SYS (pthread_attr_destroy, int, (pthread_attr_t *attr));
596# endif
597# if __GLIBC__ >= 2
598_GL_CXXALIASWARN (pthread_attr_destroy);
599# endif
600#elif defined GNULIB_POSIXCHECK
601# undef pthread_attr_destroy
602# if HAVE_RAW_DECL_PTHREAD_ATTR_DESTROY
603_GL_WARN_ON_USE (pthread_attr_destroy, "pthread_attr_destroy is not portable - "
604 "use gnulib module pthread-thread for portability");
605# endif
606#endif
607
608#if @GNULIB_PTHREAD_THREAD@
609# if @REPLACE_PTHREAD_SELF@
610# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
611# undef pthread_self
612# define pthread_self rpl_pthread_self
613# endif
614_GL_FUNCDECL_RPL (pthread_self, pthread_t, (void) _GL_ATTRIBUTE_PURE);
615_GL_CXXALIAS_RPL (pthread_self, pthread_t, (void));
616# else
617# if !@HAVE_PTHREAD_SELF@
618_GL_FUNCDECL_SYS (pthread_self, pthread_t, (void) _GL_ATTRIBUTE_PURE);
619# endif
620_GL_CXXALIAS_SYS (pthread_self, pthread_t, (void));
621# endif
622# if __GLIBC__ >= 2
623_GL_CXXALIASWARN (pthread_self);
624# endif
625#elif defined GNULIB_POSIXCHECK
626# undef pthread_self
627# if HAVE_RAW_DECL_PTHREAD_SELF
628_GL_WARN_ON_USE (pthread_self, "pthread_self is not portable - "
629 "use gnulib module pthread-thread for portability");
630# endif
631#endif
632
633#if @GNULIB_PTHREAD_THREAD@
634# if @REPLACE_PTHREAD_EQUAL@
635# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
636# undef pthread_equal
637# define pthread_equal rpl_pthread_equal
638# endif
639_GL_FUNCDECL_RPL (pthread_equal, int, (pthread_t thread1, pthread_t thread2));
640_GL_CXXALIAS_RPL (pthread_equal, int, (pthread_t thread1, pthread_t thread2));
641# else
642# if !@HAVE_PTHREAD_EQUAL@
643_GL_FUNCDECL_SYS (pthread_equal, int, (pthread_t thread1, pthread_t thread2));
644# endif
645_GL_CXXALIAS_SYS (pthread_equal, int, (pthread_t thread1, pthread_t thread2));
646# endif
647# if __GLIBC__ >= 2
648_GL_CXXALIASWARN (pthread_equal);
649# endif
650#elif defined GNULIB_POSIXCHECK
651# undef pthread_equal
652# if HAVE_RAW_DECL_PTHREAD_EQUAL
653_GL_WARN_ON_USE (pthread_equal, "pthread_equal is not portable - "
654 "use gnulib module pthread-thread for portability");
655# endif
656#endif
657
658#if @GNULIB_PTHREAD_THREAD@
659# if @REPLACE_PTHREAD_DETACH@
660# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
661# undef pthread_detach
662# define pthread_detach rpl_pthread_detach
663# endif
664_GL_FUNCDECL_RPL (pthread_detach, int, (pthread_t thread));
665_GL_CXXALIAS_RPL (pthread_detach, int, (pthread_t thread));
666# else
667# if !@HAVE_PTHREAD_DETACH@
668_GL_FUNCDECL_SYS (pthread_detach, int, (pthread_t thread));
669# endif
670_GL_CXXALIAS_SYS (pthread_detach, int, (pthread_t thread));
671# endif
672# if __GLIBC__ >= 2
673_GL_CXXALIASWARN (pthread_detach);
674# endif
675#elif defined GNULIB_POSIXCHECK
676# undef pthread_detach
677# if HAVE_RAW_DECL_PTHREAD_DETACH
678_GL_WARN_ON_USE (pthread_detach, "pthread_detach is not portable - "
679 "use gnulib module pthread-thread for portability");
680# endif
681#endif
682
683#if @GNULIB_PTHREAD_THREAD@
684# if @REPLACE_PTHREAD_JOIN@
685# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
686# undef pthread_join
687# define pthread_join rpl_pthread_join
688# endif
689_GL_FUNCDECL_RPL (pthread_join, int, (pthread_t thread, void **valuep));
690_GL_CXXALIAS_RPL (pthread_join, int, (pthread_t thread, void **valuep));
691# else
692# if !@HAVE_PTHREAD_JOIN@
693_GL_FUNCDECL_SYS (pthread_join, int, (pthread_t thread, void **valuep));
694# endif
695_GL_CXXALIAS_SYS (pthread_join, int, (pthread_t thread, void **valuep));
696# endif
697# if __GLIBC__ >= 2
698_GL_CXXALIASWARN (pthread_join);
699# endif
700#elif defined GNULIB_POSIXCHECK
701# undef pthread_join
702# if HAVE_RAW_DECL_PTHREAD_JOIN
703_GL_WARN_ON_USE (pthread_join, "pthread_join is not portable - "
704 "use gnulib module pthread-thread for portability");
705# endif
706#endif
707
708#if @GNULIB_PTHREAD_THREAD@
709# if @REPLACE_PTHREAD_EXIT@
710# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
711# undef pthread_exit
712# define pthread_exit rpl_pthread_exit
713# endif
714_GL_FUNCDECL_RPL (pthread_exit, _Noreturn void, (void *value));
715_GL_CXXALIAS_RPL (pthread_exit, void, (void *value));
716# else
717# if !@HAVE_PTHREAD_EXIT@
718_GL_FUNCDECL_SYS (pthread_exit, _Noreturn void, (void *value));
719# endif
720/* Need to cast because of AIX with xlclang++. */
721_GL_CXXALIAS_SYS_CAST (pthread_exit, void, (void *value));
722# endif
723# if __GLIBC__ >= 2
724_GL_CXXALIASWARN (pthread_exit);
725# endif
726#elif defined GNULIB_POSIXCHECK
727# undef pthread_exit
728# if HAVE_RAW_DECL_PTHREAD_EXIT
729_GL_WARN_ON_USE (pthread_exit, "pthread_exit is not portable - "
730 "use gnulib module pthread-thread for portability");
731# endif
732#endif
733
734/* =========== Once-only control (initialization) functions =========== */
735
736#if @GNULIB_PTHREAD_ONCE@
737# if @REPLACE_PTHREAD_ONCE@
738# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
739# undef pthread_once
740# define pthread_once rpl_pthread_once
741# endif
742_GL_FUNCDECL_RPL (pthread_once, int,
743 (pthread_once_t *once_control, void (*initfunction) (void))
744 _GL_ARG_NONNULL ((1, 2)));
745_GL_CXXALIAS_RPL (pthread_once, int,
746 (pthread_once_t *once_control, void (*initfunction) (void)));
747# else
748# if !@HAVE_PTHREAD_ONCE@
749_GL_FUNCDECL_SYS (pthread_once, int,
750 (pthread_once_t *once_control, void (*initfunction) (void))
751 _GL_ARG_NONNULL ((1, 2)));
752# endif
753_GL_CXXALIAS_SYS_CAST (pthread_once, int,
754 (pthread_once_t *once_control,
755 void (*initfunction) (void)));
756# endif
757# if __GLIBC__ >= 2
758_GL_CXXALIASWARN (pthread_once);
759# endif
760#elif defined GNULIB_POSIXCHECK
761# undef pthread_once
762# if HAVE_RAW_DECL_PTHREAD_ONCE
763_GL_WARN_ON_USE (pthread_once, "pthread_once is not portable - "
764 "use gnulib module pthread-once for portability");
765# endif
766#endif
767
768/* =========== Mutex functions =========== */
769
770#if @GNULIB_PTHREAD_MUTEX@
771# if @REPLACE_PTHREAD_MUTEX_INIT@
772# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
773# undef pthread_mutex_init
774# define pthread_mutex_init rpl_pthread_mutex_init
775# endif
776_GL_FUNCDECL_RPL (pthread_mutex_init, int,
777 (pthread_mutex_t *restrict mutex,
778 const pthread_mutexattr_t *restrict attr)
779 _GL_ARG_NONNULL ((1)));
780_GL_CXXALIAS_RPL (pthread_mutex_init, int,
781 (pthread_mutex_t *restrict mutex,
782 const pthread_mutexattr_t *restrict attr));
783# else
784# if !@HAVE_PTHREAD_MUTEX_INIT@
785_GL_FUNCDECL_SYS (pthread_mutex_init, int,
786 (pthread_mutex_t *restrict mutex,
787 const pthread_mutexattr_t *restrict attr)
788 _GL_ARG_NONNULL ((1)));
789# endif
790_GL_CXXALIAS_SYS (pthread_mutex_init, int,
791 (pthread_mutex_t *restrict mutex,
792 const pthread_mutexattr_t *restrict attr));
793# endif
794# if __GLIBC__ >= 2
795_GL_CXXALIASWARN (pthread_mutex_init);
796# endif
797#elif defined GNULIB_POSIXCHECK
798# undef pthread_mutex_init
799# if HAVE_RAW_DECL_PTHREAD_MUTEX_INIT
800_GL_WARN_ON_USE (pthread_mutex_init, "pthread_mutex_init is not portable - "
801 "use gnulib module pthread-mutex for portability");
802# endif
803#endif
804
805#if @GNULIB_PTHREAD_MUTEX@
806# if @REPLACE_PTHREAD_MUTEXATTR_INIT@
807# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
808# undef pthread_mutexattr_init
809# define pthread_mutexattr_init rpl_pthread_mutexattr_init
810# endif
811_GL_FUNCDECL_RPL (pthread_mutexattr_init, int, (pthread_mutexattr_t *attr)
812 _GL_ARG_NONNULL ((1)));
813_GL_CXXALIAS_RPL (pthread_mutexattr_init, int, (pthread_mutexattr_t *attr));
814# else
815# if !@HAVE_PTHREAD_MUTEXATTR_INIT@
816_GL_FUNCDECL_SYS (pthread_mutexattr_init, int, (pthread_mutexattr_t *attr)
817 _GL_ARG_NONNULL ((1)));
818# endif
819_GL_CXXALIAS_SYS (pthread_mutexattr_init, int, (pthread_mutexattr_t *attr));
820# endif
821# if __GLIBC__ >= 2
822_GL_CXXALIASWARN (pthread_mutexattr_init);
823# endif
824#elif defined GNULIB_POSIXCHECK
825# undef pthread_mutexattr_init
826# if HAVE_RAW_DECL_PTHREAD_MUTEXATTR_INIT
827_GL_WARN_ON_USE (pthread_mutexattr_init, "pthread_mutexattr_init is not portable - "
828 "use gnulib module pthread-mutex for portability");
829# endif
830#endif
831
832#if @GNULIB_PTHREAD_MUTEX@
833# if @REPLACE_PTHREAD_MUTEXATTR_GETTYPE@
834# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
835# undef pthread_mutexattr_gettype
836# define pthread_mutexattr_gettype rpl_pthread_mutexattr_gettype
837# endif
838_GL_FUNCDECL_RPL (pthread_mutexattr_gettype, int,
839 (const pthread_mutexattr_t *restrict attr,
840 int *restrict typep)
841 _GL_ARG_NONNULL ((1, 2)));
842_GL_CXXALIAS_RPL (pthread_mutexattr_gettype, int,
843 (const pthread_mutexattr_t *restrict attr,
844 int *restrict typep));
845# else
846# if !@HAVE_PTHREAD_MUTEXATTR_GETTYPE@
847_GL_FUNCDECL_SYS (pthread_mutexattr_gettype, int,
848 (const pthread_mutexattr_t *restrict attr,
849 int *restrict typep)
850 _GL_ARG_NONNULL ((1, 2)));
851# endif
852/* Need to cast, because on FreeBSD the first parameter is
853 pthread_mutexattr_t *attr. */
854_GL_CXXALIAS_SYS_CAST (pthread_mutexattr_gettype, int,
855 (const pthread_mutexattr_t *restrict attr,
856 int *restrict typep));
857# endif
858# if __GLIBC__ >= 2
859_GL_CXXALIASWARN (pthread_mutexattr_gettype);
860# endif
861#elif defined GNULIB_POSIXCHECK
862# undef pthread_mutexattr_gettype
863# if HAVE_RAW_DECL_PTHREAD_MUTEXATTR_GETTYPE
864_GL_WARN_ON_USE (pthread_mutexattr_gettype, "pthread_mutexattr_gettype is not portable - "
865 "use gnulib module pthread-mutex for portability");
866# endif
867#endif
868
869#if @GNULIB_PTHREAD_MUTEX@
870# if @REPLACE_PTHREAD_MUTEXATTR_SETTYPE@
871# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
872# undef pthread_mutexattr_settype
873# define pthread_mutexattr_settype rpl_pthread_mutexattr_settype
874# endif
875_GL_FUNCDECL_RPL (pthread_mutexattr_settype, int,
876 (pthread_mutexattr_t *attr, int type) _GL_ARG_NONNULL ((1)));
877_GL_CXXALIAS_RPL (pthread_mutexattr_settype, int,
878 (pthread_mutexattr_t *attr, int type));
879# else
880# if !@HAVE_PTHREAD_MUTEXATTR_SETTYPE@
881_GL_FUNCDECL_SYS (pthread_mutexattr_settype, int,
882 (pthread_mutexattr_t *attr, int type) _GL_ARG_NONNULL ((1)));
883# endif
884_GL_CXXALIAS_SYS (pthread_mutexattr_settype, int,
885 (pthread_mutexattr_t *attr, int type));
886# endif
887# if __GLIBC__ >= 2
888_GL_CXXALIASWARN (pthread_mutexattr_settype);
889# endif
890#elif defined GNULIB_POSIXCHECK
891# undef pthread_mutexattr_settype
892# if HAVE_RAW_DECL_PTHREAD_MUTEXATTR_SETTYPE
893_GL_WARN_ON_USE (pthread_mutexattr_settype, "pthread_mutexattr_settype is not portable - "
894 "use gnulib module pthread-mutex for portability");
895# endif
896#endif
897
898#if @GNULIB_PTHREAD_MUTEX@
899# if @REPLACE_PTHREAD_MUTEXATTR_GETROBUST@
900# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
901# undef pthread_mutexattr_getrobust
902# define pthread_mutexattr_getrobust rpl_pthread_mutexattr_getrobust
903# endif
904_GL_FUNCDECL_RPL (pthread_mutexattr_getrobust, int,
905 (const pthread_mutexattr_t *restrict attr,
906 int *restrict robustp)
907 _GL_ARG_NONNULL ((1, 2)));
908_GL_CXXALIAS_RPL (pthread_mutexattr_getrobust, int,
909 (const pthread_mutexattr_t *restrict attr,
910 int *restrict robustp));
911# else
912# if !@HAVE_PTHREAD_MUTEXATTR_GETROBUST@
913_GL_FUNCDECL_SYS (pthread_mutexattr_getrobust, int,
914 (const pthread_mutexattr_t *restrict attr,
915 int *restrict robustp)
916 _GL_ARG_NONNULL ((1, 2)));
917# endif
918/* Need to cast, because on FreeBSD the first parameter is
919 pthread_mutexattr_t *attr. */
920_GL_CXXALIAS_SYS_CAST (pthread_mutexattr_getrobust, int,
921 (const pthread_mutexattr_t *restrict attr,
922 int *restrict robustp));
923# endif
924# if __GLIBC__ >= 2
925_GL_CXXALIASWARN (pthread_mutexattr_getrobust);
926# endif
927#elif defined GNULIB_POSIXCHECK
928# undef pthread_mutexattr_getrobust
929# if HAVE_RAW_DECL_PTHREAD_MUTEXATTR_GETROBUST
930_GL_WARN_ON_USE (pthread_mutexattr_getrobust, "pthread_mutexattr_getrobust is not portable - "
931 "use gnulib module pthread-mutex for portability");
932# endif
933#endif
934
935#if @GNULIB_PTHREAD_MUTEX@
936# if @REPLACE_PTHREAD_MUTEXATTR_SETROBUST@
937# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
938# undef pthread_mutexattr_setrobust
939# define pthread_mutexattr_setrobust rpl_pthread_mutexattr_setrobust
940# endif
941_GL_FUNCDECL_RPL (pthread_mutexattr_setrobust, int,
942 (pthread_mutexattr_t *attr, int robust)
943 _GL_ARG_NONNULL ((1)));
944_GL_CXXALIAS_RPL (pthread_mutexattr_setrobust, int,
945 (pthread_mutexattr_t *attr, int robust));
946# else
947# if !@HAVE_PTHREAD_MUTEXATTR_SETROBUST@
948_GL_FUNCDECL_SYS (pthread_mutexattr_setrobust, int,
949 (pthread_mutexattr_t *attr, int robust)
950 _GL_ARG_NONNULL ((1)));
951# endif
952_GL_CXXALIAS_SYS (pthread_mutexattr_setrobust, int,
953 (pthread_mutexattr_t *attr, int robust));
954# endif
955# if __GLIBC__ >= 2
956_GL_CXXALIASWARN (pthread_mutexattr_setrobust);
957# endif
958#elif defined GNULIB_POSIXCHECK
959# undef pthread_mutexattr_setrobust
960# if HAVE_RAW_DECL_PTHREAD_MUTEXATTR_SETROBUST
961_GL_WARN_ON_USE (pthread_mutexattr_setrobust, "pthread_mutexattr_setrobust is not portable - "
962 "use gnulib module pthread-mutex for portability");
963# endif
964#endif
965
966#if @GNULIB_PTHREAD_MUTEX@
967# if @REPLACE_PTHREAD_MUTEXATTR_DESTROY@
968# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
969# undef pthread_mutexattr_destroy
970# define pthread_mutexattr_destroy rpl_pthread_mutexattr_destroy
971# endif
972_GL_FUNCDECL_RPL (pthread_mutexattr_destroy, int, (pthread_mutexattr_t *attr)
973 _GL_ARG_NONNULL ((1)));
974_GL_CXXALIAS_RPL (pthread_mutexattr_destroy, int, (pthread_mutexattr_t *attr));
975# else
976# if !@HAVE_PTHREAD_MUTEXATTR_DESTROY@
977_GL_FUNCDECL_SYS (pthread_mutexattr_destroy, int, (pthread_mutexattr_t *attr)
978 _GL_ARG_NONNULL ((1)));
979# endif
980_GL_CXXALIAS_SYS (pthread_mutexattr_destroy, int, (pthread_mutexattr_t *attr));
981# endif
982# if __GLIBC__ >= 2
983_GL_CXXALIASWARN (pthread_mutexattr_destroy);
984# endif
985#elif defined GNULIB_POSIXCHECK
986# undef pthread_mutexattr_destroy
987# if HAVE_RAW_DECL_PTHREAD_MUTEXATTR_DESTROY
988_GL_WARN_ON_USE (pthread_mutexattr_destroy, "pthread_mutexattr_destroy is not portable - "
989 "use gnulib module pthread-mutex for portability");
990# endif
991#endif
992
993#if @GNULIB_PTHREAD_MUTEX@
994# if @REPLACE_PTHREAD_MUTEX_LOCK@
995# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
996# undef pthread_mutex_lock
997# define pthread_mutex_lock rpl_pthread_mutex_lock
998# endif
999_GL_FUNCDECL_RPL (pthread_mutex_lock, int, (pthread_mutex_t *mutex)
1000 _GL_ARG_NONNULL ((1)));
1001_GL_CXXALIAS_RPL (pthread_mutex_lock, int, (pthread_mutex_t *mutex));
1002# else
1003# if !@HAVE_PTHREAD_MUTEX_LOCK@
1004_GL_FUNCDECL_SYS (pthread_mutex_lock, int, (pthread_mutex_t *mutex)
1005 _GL_ARG_NONNULL ((1)));
1006# endif
1007_GL_CXXALIAS_SYS (pthread_mutex_lock, int, (pthread_mutex_t *mutex));
1008# endif
1009# if __GLIBC__ >= 2
1010_GL_CXXALIASWARN (pthread_mutex_lock);
1011# endif
1012#elif defined GNULIB_POSIXCHECK
1013# undef pthread_mutex_lock
1014# if HAVE_RAW_DECL_PTHREAD_MUTEX_LOCK
1015_GL_WARN_ON_USE (pthread_mutex_lock, "pthread_mutex_lock is not portable - "
1016 "use gnulib module pthread-mutex for portability");
1017# endif
1018#endif
1019
1020#if @GNULIB_PTHREAD_MUTEX@
1021# if @REPLACE_PTHREAD_MUTEX_TRYLOCK@
1022# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1023# undef pthread_mutex_trylock
1024# define pthread_mutex_trylock rpl_pthread_mutex_trylock
1025# endif
1026_GL_FUNCDECL_RPL (pthread_mutex_trylock, int, (pthread_mutex_t *mutex)
1027 _GL_ARG_NONNULL ((1)));
1028_GL_CXXALIAS_RPL (pthread_mutex_trylock, int, (pthread_mutex_t *mutex));
1029# else
1030# if !@HAVE_PTHREAD_MUTEX_TRYLOCK@
1031_GL_FUNCDECL_SYS (pthread_mutex_trylock, int, (pthread_mutex_t *mutex)
1032 _GL_ARG_NONNULL ((1)));
1033# endif
1034_GL_CXXALIAS_SYS (pthread_mutex_trylock, int, (pthread_mutex_t *mutex));
1035# endif
1036# if __GLIBC__ >= 2
1037_GL_CXXALIASWARN (pthread_mutex_trylock);
1038# endif
1039#elif defined GNULIB_POSIXCHECK
1040# undef pthread_mutex_trylock
1041# if HAVE_RAW_DECL_PTHREAD_MUTEX_TRYLOCK
1042_GL_WARN_ON_USE (pthread_mutex_trylock, "pthread_mutex_trylock is not portable - "
1043 "use gnulib module pthread-mutex for portability");
1044# endif
1045#endif
1046
1047#if @GNULIB_PTHREAD_MUTEX_TIMEDLOCK@
1048# if @REPLACE_PTHREAD_MUTEX_TIMEDLOCK@
1049# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1050# undef pthread_mutex_timedlock
1051# define pthread_mutex_timedlock rpl_pthread_mutex_timedlock
1052# endif
1053_GL_FUNCDECL_RPL (pthread_mutex_timedlock, int,
1054 (pthread_mutex_t *restrict mutex,
1055 const struct timespec *restrict abstime)
1056 _GL_ARG_NONNULL ((1, 2)));
1057_GL_CXXALIAS_RPL (pthread_mutex_timedlock, int,
1058 (pthread_mutex_t *restrict mutex,
1059 const struct timespec *restrict abstime));
1060# else
1061# if !@HAVE_PTHREAD_MUTEX_TIMEDLOCK@
1062_GL_FUNCDECL_SYS (pthread_mutex_timedlock, int,
1063 (pthread_mutex_t *restrict mutex,
1064 const struct timespec *restrict abstime)
1065 _GL_ARG_NONNULL ((1, 2)));
1066# endif
1067_GL_CXXALIAS_SYS (pthread_mutex_timedlock, int,
1068 (pthread_mutex_t *restrict mutex,
1069 const struct timespec *restrict abstime));
1070# endif
1071# if __GLIBC__ >= 2
1072_GL_CXXALIASWARN (pthread_mutex_timedlock);
1073# endif
1074#elif defined GNULIB_POSIXCHECK
1075# undef pthread_mutex_timedlock
1076# if HAVE_RAW_DECL_PTHREAD_MUTEX_TIMEDLOCK
1077_GL_WARN_ON_USE (pthread_mutex_timedlock, "pthread_mutex_timedlock is not portable - "
1078 "use gnulib module pthread_mutex_timedlock for portability");
1079# endif
1080#endif
1081
1082#if @GNULIB_PTHREAD_MUTEX@
1083# if @REPLACE_PTHREAD_MUTEX_UNLOCK@
1084# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1085# undef pthread_mutex_unlock
1086# define pthread_mutex_unlock rpl_pthread_mutex_unlock
1087# endif
1088_GL_FUNCDECL_RPL (pthread_mutex_unlock, int, (pthread_mutex_t *mutex)
1089 _GL_ARG_NONNULL ((1)));
1090_GL_CXXALIAS_RPL (pthread_mutex_unlock, int, (pthread_mutex_t *mutex));
1091# else
1092# if !@HAVE_PTHREAD_MUTEX_UNLOCK@
1093_GL_FUNCDECL_SYS (pthread_mutex_unlock, int, (pthread_mutex_t *mutex)
1094 _GL_ARG_NONNULL ((1)));
1095# endif
1096_GL_CXXALIAS_SYS (pthread_mutex_unlock, int, (pthread_mutex_t *mutex));
1097# endif
1098# if __GLIBC__ >= 2
1099_GL_CXXALIASWARN (pthread_mutex_unlock);
1100# endif
1101#elif defined GNULIB_POSIXCHECK
1102# undef pthread_mutex_unlock
1103# if HAVE_RAW_DECL_PTHREAD_MUTEX_UNLOCK
1104_GL_WARN_ON_USE (pthread_mutex_unlock, "pthread_mutex_unlock is not portable - "
1105 "use gnulib module pthread-mutex for portability");
1106# endif
1107#endif
1108
1109#if @GNULIB_PTHREAD_MUTEX@
1110# if @REPLACE_PTHREAD_MUTEX_DESTROY@
1111# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1112# undef pthread_mutex_destroy
1113# define pthread_mutex_destroy rpl_pthread_mutex_destroy
1114# endif
1115_GL_FUNCDECL_RPL (pthread_mutex_destroy, int, (pthread_mutex_t *mutex)
1116 _GL_ARG_NONNULL ((1)));
1117_GL_CXXALIAS_RPL (pthread_mutex_destroy, int, (pthread_mutex_t *mutex));
1118# else
1119# if !@HAVE_PTHREAD_MUTEX_DESTROY@
1120_GL_FUNCDECL_SYS (pthread_mutex_destroy, int, (pthread_mutex_t *mutex)
1121 _GL_ARG_NONNULL ((1)));
1122# endif
1123_GL_CXXALIAS_SYS (pthread_mutex_destroy, int, (pthread_mutex_t *mutex));
1124# endif
1125# if __GLIBC__ >= 2
1126_GL_CXXALIASWARN (pthread_mutex_destroy);
1127# endif
1128#elif defined GNULIB_POSIXCHECK
1129# undef pthread_mutex_destroy
1130# if HAVE_RAW_DECL_PTHREAD_MUTEX_DESTROY
1131_GL_WARN_ON_USE (pthread_mutex_destroy, "pthread_mutex_destroy is not portable - "
1132 "use gnulib module pthread-mutex for portability");
1133# endif
1134#endif
1135
1136/* =========== Read-write lock functions =========== */
1137
1138#if @GNULIB_PTHREAD_RWLOCK@
1139# if @REPLACE_PTHREAD_RWLOCK_INIT@
1140# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1141# undef pthread_rwlock_init
1142# define pthread_rwlock_init rpl_pthread_rwlock_init
1143# endif
1144_GL_FUNCDECL_RPL (pthread_rwlock_init, int,
1145 (pthread_rwlock_t *restrict lock,
1146 const pthread_rwlockattr_t *restrict attr)
1147 _GL_ARG_NONNULL ((1)));
1148_GL_CXXALIAS_RPL (pthread_rwlock_init, int,
1149 (pthread_rwlock_t *restrict lock,
1150 const pthread_rwlockattr_t *restrict attr));
1151# else
1152# if !@HAVE_PTHREAD_RWLOCK_INIT@
1153_GL_FUNCDECL_SYS (pthread_rwlock_init, int,
1154 (pthread_rwlock_t *restrict lock,
1155 const pthread_rwlockattr_t *restrict attr)
1156 _GL_ARG_NONNULL ((1)));
1157# endif
1158_GL_CXXALIAS_SYS (pthread_rwlock_init, int,
1159 (pthread_rwlock_t *restrict lock,
1160 const pthread_rwlockattr_t *restrict attr));
1161# endif
1162# if __GLIBC__ >= 2
1163_GL_CXXALIASWARN (pthread_rwlock_init);
1164# endif
1165#elif defined GNULIB_POSIXCHECK
1166# undef pthread_rwlock_init
1167# if HAVE_RAW_DECL_PTHREAD_RWLOCK_INIT
1168_GL_WARN_ON_USE (pthread_rwlock_init, "pthread_rwlock_init is not portable - "
1169 "use gnulib module pthread-rwlock for portability");
1170# endif
1171#endif
1172
1173#if @GNULIB_PTHREAD_RWLOCK@
1174# if @REPLACE_PTHREAD_RWLOCKATTR_INIT@
1175# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1176# undef pthread_rwlockattr_init
1177# define pthread_rwlockattr_init rpl_pthread_rwlockattr_init
1178# endif
1179_GL_FUNCDECL_RPL (pthread_rwlockattr_init, int, (pthread_rwlockattr_t *attr)
1180 _GL_ARG_NONNULL ((1)));
1181_GL_CXXALIAS_RPL (pthread_rwlockattr_init, int, (pthread_rwlockattr_t *attr));
1182# else
1183# if !@HAVE_PTHREAD_RWLOCKATTR_INIT@
1184_GL_FUNCDECL_SYS (pthread_rwlockattr_init, int, (pthread_rwlockattr_t *attr)
1185 _GL_ARG_NONNULL ((1)));
1186# endif
1187_GL_CXXALIAS_SYS (pthread_rwlockattr_init, int, (pthread_rwlockattr_t *attr));
1188# endif
1189# if __GLIBC__ >= 2
1190_GL_CXXALIASWARN (pthread_rwlockattr_init);
1191# endif
1192#elif defined GNULIB_POSIXCHECK
1193# undef pthread_rwlockattr_init
1194# if HAVE_RAW_DECL_PTHREAD_RWLOCKATTR_INIT
1195_GL_WARN_ON_USE (pthread_rwlockattr_init, "pthread_rwlockattr_init is not portable - "
1196 "use gnulib module pthread-rwlock for portability");
1197# endif
1198#endif
1199
1200#if @GNULIB_PTHREAD_RWLOCK@
1201# if @REPLACE_PTHREAD_RWLOCKATTR_DESTROY@
1202# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1203# undef pthread_rwlockattr_destroy
1204# define pthread_rwlockattr_destroy rpl_pthread_rwlockattr_destroy
1205# endif
1206_GL_FUNCDECL_RPL (pthread_rwlockattr_destroy, int,
1207 (pthread_rwlockattr_t *attr) _GL_ARG_NONNULL ((1)));
1208_GL_CXXALIAS_RPL (pthread_rwlockattr_destroy, int,
1209 (pthread_rwlockattr_t *attr));
1210# else
1211# if !@HAVE_PTHREAD_RWLOCKATTR_DESTROY@
1212_GL_FUNCDECL_SYS (pthread_rwlockattr_destroy, int,
1213 (pthread_rwlockattr_t *attr) _GL_ARG_NONNULL ((1)));
1214# endif
1215_GL_CXXALIAS_SYS (pthread_rwlockattr_destroy, int,
1216 (pthread_rwlockattr_t *attr));
1217# endif
1218# if __GLIBC__ >= 2
1219_GL_CXXALIASWARN (pthread_rwlockattr_destroy);
1220# endif
1221#elif defined GNULIB_POSIXCHECK
1222# undef pthread_rwlockattr_destroy
1223# if HAVE_RAW_DECL_PTHREAD_RWLOCKATTR_DESTROY
1224_GL_WARN_ON_USE (pthread_rwlockattr_destroy, "pthread_rwlockattr_destroy is not portable - "
1225 "use gnulib module pthread-rwlock for portability");
1226# endif
1227#endif
1228
1229#if @GNULIB_PTHREAD_RWLOCK@
1230# if @REPLACE_PTHREAD_RWLOCK_RDLOCK@
1231# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1232# undef pthread_rwlock_rdlock
1233# define pthread_rwlock_rdlock rpl_pthread_rwlock_rdlock
1234# endif
1235_GL_FUNCDECL_RPL (pthread_rwlock_rdlock, int, (pthread_rwlock_t *lock)
1236 _GL_ARG_NONNULL ((1)));
1237_GL_CXXALIAS_RPL (pthread_rwlock_rdlock, int, (pthread_rwlock_t *lock));
1238# else
1239# if !@HAVE_PTHREAD_RWLOCK_RDLOCK@
1240_GL_FUNCDECL_SYS (pthread_rwlock_rdlock, int, (pthread_rwlock_t *lock)
1241 _GL_ARG_NONNULL ((1)));
1242# endif
1243_GL_CXXALIAS_SYS (pthread_rwlock_rdlock, int, (pthread_rwlock_t *lock));
1244# endif
1245# if __GLIBC__ >= 2
1246_GL_CXXALIASWARN (pthread_rwlock_rdlock);
1247# endif
1248#elif defined GNULIB_POSIXCHECK
1249# undef pthread_rwlock_rdlock
1250# if HAVE_RAW_DECL_PTHREAD_RWLOCK_RDLOCK
1251_GL_WARN_ON_USE (pthread_rwlock_rdlock, "pthread_rwlock_rdlock is not portable - "
1252 "use gnulib module pthread-rwlock for portability");
1253# endif
1254#endif
1255
1256#if @GNULIB_PTHREAD_RWLOCK@
1257# if @REPLACE_PTHREAD_RWLOCK_WRLOCK@
1258# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1259# undef pthread_rwlock_wrlock
1260# define pthread_rwlock_wrlock rpl_pthread_rwlock_wrlock
1261# endif
1262_GL_FUNCDECL_RPL (pthread_rwlock_wrlock, int, (pthread_rwlock_t *lock)
1263 _GL_ARG_NONNULL ((1)));
1264_GL_CXXALIAS_RPL (pthread_rwlock_wrlock, int, (pthread_rwlock_t *lock));
1265# else
1266# if !@HAVE_PTHREAD_RWLOCK_WRLOCK@
1267_GL_FUNCDECL_SYS (pthread_rwlock_wrlock, int, (pthread_rwlock_t *lock)
1268 _GL_ARG_NONNULL ((1)));
1269# endif
1270_GL_CXXALIAS_SYS (pthread_rwlock_wrlock, int, (pthread_rwlock_t *lock));
1271# endif
1272# if __GLIBC__ >= 2
1273_GL_CXXALIASWARN (pthread_rwlock_wrlock);
1274# endif
1275#elif defined GNULIB_POSIXCHECK
1276# undef pthread_rwlock_wrlock
1277# if HAVE_RAW_DECL_PTHREAD_RWLOCK_WRLOCK
1278_GL_WARN_ON_USE (pthread_rwlock_wrlock, "pthread_rwlock_wrlock is not portable - "
1279 "use gnulib module pthread-rwlock for portability");
1280# endif
1281#endif
1282
1283#if @GNULIB_PTHREAD_RWLOCK@
1284# if @REPLACE_PTHREAD_RWLOCK_TRYRDLOCK@
1285# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1286# undef pthread_rwlock_tryrdlock
1287# define pthread_rwlock_tryrdlock rpl_pthread_rwlock_tryrdlock
1288# endif
1289_GL_FUNCDECL_RPL (pthread_rwlock_tryrdlock, int, (pthread_rwlock_t *lock)
1290 _GL_ARG_NONNULL ((1)));
1291_GL_CXXALIAS_RPL (pthread_rwlock_tryrdlock, int, (pthread_rwlock_t *lock));
1292# else
1293# if !@HAVE_PTHREAD_RWLOCK_TRYRDLOCK@
1294_GL_FUNCDECL_SYS (pthread_rwlock_tryrdlock, int, (pthread_rwlock_t *lock)
1295 _GL_ARG_NONNULL ((1)));
1296# endif
1297_GL_CXXALIAS_SYS (pthread_rwlock_tryrdlock, int, (pthread_rwlock_t *lock));
1298# endif
1299# if __GLIBC__ >= 2
1300_GL_CXXALIASWARN (pthread_rwlock_tryrdlock);
1301# endif
1302#elif defined GNULIB_POSIXCHECK
1303# undef pthread_rwlock_tryrdlock
1304# if HAVE_RAW_DECL_PTHREAD_RWLOCK_TRYRDLOCK
1305_GL_WARN_ON_USE (pthread_rwlock_tryrdlock, "pthread_rwlock_tryrdlock is not portable - "
1306 "use gnulib module pthread-rwlock for portability");
1307# endif
1308#endif
1309
1310#if @GNULIB_PTHREAD_RWLOCK@
1311# if @REPLACE_PTHREAD_RWLOCK_TRYWRLOCK@
1312# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1313# undef pthread_rwlock_trywrlock
1314# define pthread_rwlock_trywrlock rpl_pthread_rwlock_trywrlock
1315# endif
1316_GL_FUNCDECL_RPL (pthread_rwlock_trywrlock, int, (pthread_rwlock_t *lock)
1317 _GL_ARG_NONNULL ((1)));
1318_GL_CXXALIAS_RPL (pthread_rwlock_trywrlock, int, (pthread_rwlock_t *lock));
1319# else
1320# if !@HAVE_PTHREAD_RWLOCK_TRYWRLOCK@
1321_GL_FUNCDECL_SYS (pthread_rwlock_trywrlock, int, (pthread_rwlock_t *lock)
1322 _GL_ARG_NONNULL ((1)));
1323# endif
1324_GL_CXXALIAS_SYS (pthread_rwlock_trywrlock, int, (pthread_rwlock_t *lock));
1325# endif
1326# if __GLIBC__ >= 2
1327_GL_CXXALIASWARN (pthread_rwlock_trywrlock);
1328# endif
1329#elif defined GNULIB_POSIXCHECK
1330# undef pthread_rwlock_trywrlock
1331# if HAVE_RAW_DECL_PTHREAD_RWLOCK_TRYWRLOCK
1332_GL_WARN_ON_USE (pthread_rwlock_trywrlock, "pthread_rwlock_trywrlock is not portable - "
1333 "use gnulib module pthread-rwlock for portability");
1334# endif
1335#endif
1336
1337#if @GNULIB_PTHREAD_RWLOCK@
1338# if @REPLACE_PTHREAD_RWLOCK_TIMEDRDLOCK@
1339# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1340# undef pthread_rwlock_timedrdlock
1341# define pthread_rwlock_timedrdlock rpl_pthread_rwlock_timedrdlock
1342# endif
1343_GL_FUNCDECL_RPL (pthread_rwlock_timedrdlock, int,
1344 (pthread_rwlock_t *restrict lock,
1345 const struct timespec *restrict abstime)
1346 _GL_ARG_NONNULL ((1, 2)));
1347_GL_CXXALIAS_RPL (pthread_rwlock_timedrdlock, int,
1348 (pthread_rwlock_t *restrict lock,
1349 const struct timespec *restrict abstime));
1350# else
1351# if !@HAVE_PTHREAD_RWLOCK_TIMEDRDLOCK@
1352_GL_FUNCDECL_SYS (pthread_rwlock_timedrdlock, int,
1353 (pthread_rwlock_t *restrict lock,
1354 const struct timespec *restrict abstime)
1355 _GL_ARG_NONNULL ((1, 2)));
1356# endif
1357_GL_CXXALIAS_SYS (pthread_rwlock_timedrdlock, int,
1358 (pthread_rwlock_t *restrict lock,
1359 const struct timespec *restrict abstime));
1360# endif
1361# if __GLIBC__ >= 2
1362_GL_CXXALIASWARN (pthread_rwlock_timedrdlock);
1363# endif
1364#elif defined GNULIB_POSIXCHECK
1365# undef pthread_rwlock_timedrdlock
1366# if HAVE_RAW_DECL_PTHREAD_RWLOCK_TIMEDRDLOCK
1367_GL_WARN_ON_USE (pthread_rwlock_timedrdlock, "pthread_rwlock_timedrdlock is not portable - "
1368 "use gnulib module pthread-rwlock for portability");
1369# endif
1370#endif
1371
1372#if @GNULIB_PTHREAD_RWLOCK@
1373# if @REPLACE_PTHREAD_RWLOCK_TIMEDWRLOCK@
1374# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1375# undef pthread_rwlock_timedwrlock
1376# define pthread_rwlock_timedwrlock rpl_pthread_rwlock_timedwrlock
1377# endif
1378_GL_FUNCDECL_RPL (pthread_rwlock_timedwrlock, int,
1379 (pthread_rwlock_t *restrict lock,
1380 const struct timespec *restrict abstime)
1381 _GL_ARG_NONNULL ((1, 2)));
1382_GL_CXXALIAS_RPL (pthread_rwlock_timedwrlock, int,
1383 (pthread_rwlock_t *restrict lock,
1384 const struct timespec *restrict abstime));
1385# else
1386# if !@HAVE_PTHREAD_RWLOCK_TIMEDWRLOCK@
1387_GL_FUNCDECL_SYS (pthread_rwlock_timedwrlock, int,
1388 (pthread_rwlock_t *restrict lock,
1389 const struct timespec *restrict abstime)
1390 _GL_ARG_NONNULL ((1, 2)));
1391# endif
1392_GL_CXXALIAS_SYS (pthread_rwlock_timedwrlock, int,
1393 (pthread_rwlock_t *restrict lock,
1394 const struct timespec *restrict abstime));
1395# endif
1396# if __GLIBC__ >= 2
1397_GL_CXXALIASWARN (pthread_rwlock_timedwrlock);
1398# endif
1399#elif defined GNULIB_POSIXCHECK
1400# undef pthread_rwlock_timedwrlock
1401# if HAVE_RAW_DECL_PTHREAD_RWLOCK_TIMEDWRLOCK
1402_GL_WARN_ON_USE (pthread_rwlock_timedwrlock, "pthread_rwlock_timedwrlock is not portable - "
1403 "use gnulib module pthread-rwlock for portability");
1404# endif
1405#endif
1406
1407#if @GNULIB_PTHREAD_RWLOCK@
1408# if @REPLACE_PTHREAD_RWLOCK_UNLOCK@
1409# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1410# undef pthread_rwlock_unlock
1411# define pthread_rwlock_unlock rpl_pthread_rwlock_unlock
1412# endif
1413_GL_FUNCDECL_RPL (pthread_rwlock_unlock, int, (pthread_rwlock_t *lock)
1414 _GL_ARG_NONNULL ((1)));
1415_GL_CXXALIAS_RPL (pthread_rwlock_unlock, int, (pthread_rwlock_t *lock));
1416# else
1417# if !@HAVE_PTHREAD_RWLOCK_UNLOCK@
1418_GL_FUNCDECL_SYS (pthread_rwlock_unlock, int, (pthread_rwlock_t *lock)
1419 _GL_ARG_NONNULL ((1)));
1420# endif
1421_GL_CXXALIAS_SYS (pthread_rwlock_unlock, int, (pthread_rwlock_t *lock));
1422# endif
1423# if __GLIBC__ >= 2
1424_GL_CXXALIASWARN (pthread_rwlock_unlock);
1425# endif
1426#elif defined GNULIB_POSIXCHECK
1427# undef pthread_rwlock_unlock
1428# if HAVE_RAW_DECL_PTHREAD_RWLOCK_UNLOCK
1429_GL_WARN_ON_USE (pthread_rwlock_unlock, "pthread_rwlock_unlock is not portable - "
1430 "use gnulib module pthread-rwlock for portability");
1431# endif
1432#endif
1433
1434#if @GNULIB_PTHREAD_RWLOCK@
1435# if @REPLACE_PTHREAD_RWLOCK_DESTROY@
1436# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1437# undef pthread_rwlock_destroy
1438# define pthread_rwlock_destroy rpl_pthread_rwlock_destroy
1439# endif
1440_GL_FUNCDECL_RPL (pthread_rwlock_destroy, int, (pthread_rwlock_t *lock)
1441 _GL_ARG_NONNULL ((1)));
1442_GL_CXXALIAS_RPL (pthread_rwlock_destroy, int, (pthread_rwlock_t *lock));
1443# else
1444# if !@HAVE_PTHREAD_RWLOCK_DESTROY@
1445_GL_FUNCDECL_SYS (pthread_rwlock_destroy, int, (pthread_rwlock_t *lock)
1446 _GL_ARG_NONNULL ((1)));
1447# endif
1448_GL_CXXALIAS_SYS (pthread_rwlock_destroy, int, (pthread_rwlock_t *lock));
1449# endif
1450# if __GLIBC__ >= 2
1451_GL_CXXALIASWARN (pthread_rwlock_destroy);
1452# endif
1453#elif defined GNULIB_POSIXCHECK
1454# undef pthread_rwlock_destroy
1455# if HAVE_RAW_DECL_PTHREAD_RWLOCK_DESTROY
1456_GL_WARN_ON_USE (pthread_rwlock_destroy, "pthread_rwlock_destroy is not portable - "
1457 "use gnulib module pthread-rwlock for portability");
1458# endif
1459#endif
1460
1461/* =========== Condition variable functions =========== */
1462
1463#if @GNULIB_PTHREAD_COND@
1464# if @REPLACE_PTHREAD_COND_INIT@
1465# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1466# undef pthread_cond_init
1467# define pthread_cond_init rpl_pthread_cond_init
1468# endif
1469_GL_FUNCDECL_RPL (pthread_cond_init, int,
1470 (pthread_cond_t *restrict cond,
1471 const pthread_condattr_t *restrict attr)
1472 _GL_ARG_NONNULL ((1)));
1473_GL_CXXALIAS_RPL (pthread_cond_init, int,
1474 (pthread_cond_t *restrict cond,
1475 const pthread_condattr_t *restrict attr));
1476# else
1477# if !@HAVE_PTHREAD_COND_INIT@
1478_GL_FUNCDECL_SYS (pthread_cond_init, int,
1479 (pthread_cond_t *restrict cond,
1480 const pthread_condattr_t *restrict attr)
1481 _GL_ARG_NONNULL ((1)));
1482# endif
1483_GL_CXXALIAS_SYS (pthread_cond_init, int,
1484 (pthread_cond_t *restrict cond,
1485 const pthread_condattr_t *restrict attr));
1486# endif
1487# if __GLIBC__ >= 2
1488_GL_CXXALIASWARN (pthread_cond_init);
1489# endif
1490#elif defined GNULIB_POSIXCHECK
1491# undef pthread_cond_init
1492# if HAVE_RAW_DECL_PTHREAD_COND_INIT
1493_GL_WARN_ON_USE (pthread_cond_init, "pthread_cond_init is not portable - "
1494 "use gnulib module pthread-cond for portability");
1495# endif
1496#endif
1497
1498#if @GNULIB_PTHREAD_COND@
1499# if @REPLACE_PTHREAD_CONDATTR_INIT@
1500# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1501# undef pthread_condattr_init
1502# define pthread_condattr_init rpl_pthread_condattr_init
1503# endif
1504_GL_FUNCDECL_RPL (pthread_condattr_init, int, (pthread_condattr_t *attr)
1505 _GL_ARG_NONNULL ((1)));
1506_GL_CXXALIAS_RPL (pthread_condattr_init, int, (pthread_condattr_t *attr));
1507# else
1508# if !@HAVE_PTHREAD_CONDATTR_INIT@
1509_GL_FUNCDECL_SYS (pthread_condattr_init, int, (pthread_condattr_t *attr)
1510 _GL_ARG_NONNULL ((1)));
1511# endif
1512_GL_CXXALIAS_SYS (pthread_condattr_init, int, (pthread_condattr_t *attr));
1513# endif
1514# if __GLIBC__ >= 2
1515_GL_CXXALIASWARN (pthread_condattr_init);
1516# endif
1517#elif defined GNULIB_POSIXCHECK
1518# undef pthread_condattr_init
1519# if HAVE_RAW_DECL_PTHREAD_CONDATTR_INIT
1520_GL_WARN_ON_USE (pthread_condattr_init, "pthread_condattr_init is not portable - "
1521 "use gnulib module pthread-cond for portability");
1522# endif
1523#endif
1524
1525#if @GNULIB_PTHREAD_COND@
1526# if @REPLACE_PTHREAD_CONDATTR_DESTROY@
1527# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1528# undef pthread_condattr_destroy
1529# define pthread_condattr_destroy rpl_pthread_condattr_destroy
1530# endif
1531_GL_FUNCDECL_RPL (pthread_condattr_destroy, int, (pthread_condattr_t *attr)
1532 _GL_ARG_NONNULL ((1)));
1533_GL_CXXALIAS_RPL (pthread_condattr_destroy, int, (pthread_condattr_t *attr));
1534# else
1535# if !@HAVE_PTHREAD_CONDATTR_DESTROY@
1536_GL_FUNCDECL_SYS (pthread_condattr_destroy, int, (pthread_condattr_t *attr)
1537 _GL_ARG_NONNULL ((1)));
1538# endif
1539_GL_CXXALIAS_SYS (pthread_condattr_destroy, int, (pthread_condattr_t *attr));
1540# endif
1541# if __GLIBC__ >= 2
1542_GL_CXXALIASWARN (pthread_condattr_destroy);
1543# endif
1544#elif defined GNULIB_POSIXCHECK
1545# undef pthread_condattr_destroy
1546# if HAVE_RAW_DECL_PTHREAD_CONDATTR_DESTROY
1547_GL_WARN_ON_USE (pthread_condattr_destroy, "pthread_condattr_destroy is not portable - "
1548 "use gnulib module pthread-cond for portability");
1549# endif
1550#endif
1551
1552#if @GNULIB_PTHREAD_COND@
1553# if @REPLACE_PTHREAD_COND_WAIT@
1554# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1555# undef pthread_cond_wait
1556# define pthread_cond_wait rpl_pthread_cond_wait
1557# endif
1558_GL_FUNCDECL_RPL (pthread_cond_wait, int,
1559 (pthread_cond_t *restrict cond,
1560 pthread_mutex_t *restrict mutex)
1561 _GL_ARG_NONNULL ((1, 2)));
1562_GL_CXXALIAS_RPL (pthread_cond_wait, int,
1563 (pthread_cond_t *restrict cond,
1564 pthread_mutex_t *restrict mutex));
1565# else
1566# if !@HAVE_PTHREAD_COND_WAIT@
1567_GL_FUNCDECL_SYS (pthread_cond_wait, int,
1568 (pthread_cond_t *restrict cond,
1569 pthread_mutex_t *restrict mutex)
1570 _GL_ARG_NONNULL ((1, 2)));
1571# endif
1572_GL_CXXALIAS_SYS (pthread_cond_wait, int,
1573 (pthread_cond_t *restrict cond,
1574 pthread_mutex_t *restrict mutex));
1575# endif
1576# if __GLIBC__ >= 2
1577_GL_CXXALIASWARN (pthread_cond_wait);
1578# endif
1579#elif defined GNULIB_POSIXCHECK
1580# undef pthread_cond_wait
1581# if HAVE_RAW_DECL_PTHREAD_COND_WAIT
1582_GL_WARN_ON_USE (pthread_cond_wait, "pthread_cond_wait is not portable - "
1583 "use gnulib module pthread-cond for portability");
1584# endif
1585#endif
1586
1587#if @GNULIB_PTHREAD_COND@
1588# if @REPLACE_PTHREAD_COND_TIMEDWAIT@
1589# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1590# undef pthread_cond_timedwait
1591# define pthread_cond_timedwait rpl_pthread_cond_timedwait
1592# endif
1593_GL_FUNCDECL_RPL (pthread_cond_timedwait, int,
1594 (pthread_cond_t *restrict cond,
1595 pthread_mutex_t *restrict mutex,
1596 const struct timespec *restrict abstime)
1597 _GL_ARG_NONNULL ((1, 2, 3)));
1598_GL_CXXALIAS_RPL (pthread_cond_timedwait, int,
1599 (pthread_cond_t *restrict cond,
1600 pthread_mutex_t *restrict mutex,
1601 const struct timespec *restrict abstime));
1602# else
1603# if !@HAVE_PTHREAD_COND_TIMEDWAIT@
1604_GL_FUNCDECL_SYS (pthread_cond_timedwait, int,
1605 (pthread_cond_t *restrict cond,
1606 pthread_mutex_t *restrict mutex,
1607 const struct timespec *restrict abstime)
1608 _GL_ARG_NONNULL ((1, 2, 3)));
1609# endif
1610_GL_CXXALIAS_SYS (pthread_cond_timedwait, int,
1611 (pthread_cond_t *restrict cond,
1612 pthread_mutex_t *restrict mutex,
1613 const struct timespec *restrict abstime));
1614# endif
1615# if __GLIBC__ >= 2
1616_GL_CXXALIASWARN (pthread_cond_timedwait);
1617# endif
1618#elif defined GNULIB_POSIXCHECK
1619# undef pthread_cond_timedwait
1620# if HAVE_RAW_DECL_PTHREAD_COND_TIMEDWAIT
1621_GL_WARN_ON_USE (pthread_cond_timedwait, "pthread_cond_timedwait is not portable - "
1622 "use gnulib module pthread-cond for portability");
1623# endif
1624#endif
1625
1626#if @GNULIB_PTHREAD_COND@
1627# if @REPLACE_PTHREAD_COND_SIGNAL@
1628# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1629# undef pthread_cond_signal
1630# define pthread_cond_signal rpl_pthread_cond_signal
1631# endif
1632_GL_FUNCDECL_RPL (pthread_cond_signal, int, (pthread_cond_t *cond)
1633 _GL_ARG_NONNULL ((1)));
1634_GL_CXXALIAS_RPL (pthread_cond_signal, int, (pthread_cond_t *cond));
1635# else
1636# if !@HAVE_PTHREAD_COND_SIGNAL@
1637_GL_FUNCDECL_SYS (pthread_cond_signal, int, (pthread_cond_t *cond)
1638 _GL_ARG_NONNULL ((1)));
1639# endif
1640_GL_CXXALIAS_SYS (pthread_cond_signal, int, (pthread_cond_t *cond));
1641# endif
1642# if __GLIBC__ >= 2
1643_GL_CXXALIASWARN (pthread_cond_signal);
1644# endif
1645#elif defined GNULIB_POSIXCHECK
1646# undef pthread_cond_signal
1647# if HAVE_RAW_DECL_PTHREAD_COND_SIGNAL
1648_GL_WARN_ON_USE (pthread_cond_signal, "pthread_cond_signal is not portable - "
1649 "use gnulib module pthread-cond for portability");
1650# endif
1651#endif
1652
1653#if @GNULIB_PTHREAD_COND@
1654# if @REPLACE_PTHREAD_COND_BROADCAST@
1655# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1656# undef pthread_cond_broadcast
1657# define pthread_cond_broadcast rpl_pthread_cond_broadcast
1658# endif
1659_GL_FUNCDECL_RPL (pthread_cond_broadcast, int, (pthread_cond_t *cond)
1660 _GL_ARG_NONNULL ((1)));
1661_GL_CXXALIAS_RPL (pthread_cond_broadcast, int, (pthread_cond_t *cond));
1662# else
1663# if !@HAVE_PTHREAD_COND_BROADCAST@
1664_GL_FUNCDECL_SYS (pthread_cond_broadcast, int, (pthread_cond_t *cond)
1665 _GL_ARG_NONNULL ((1)));
1666# endif
1667_GL_CXXALIAS_SYS (pthread_cond_broadcast, int, (pthread_cond_t *cond));
1668# endif
1669# if __GLIBC__ >= 2
1670_GL_CXXALIASWARN (pthread_cond_broadcast);
1671# endif
1672#elif defined GNULIB_POSIXCHECK
1673# undef pthread_cond_broadcast
1674# if HAVE_RAW_DECL_PTHREAD_COND_BROADCAST
1675_GL_WARN_ON_USE (pthread_cond_broadcast, "pthread_cond_broadcast is not portable - "
1676 "use gnulib module pthread-cond for portability");
1677# endif
1678#endif
1679
1680#if @GNULIB_PTHREAD_COND@
1681# if @REPLACE_PTHREAD_COND_DESTROY@
1682# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1683# undef pthread_cond_destroy
1684# define pthread_cond_destroy rpl_pthread_cond_destroy
1685# endif
1686_GL_FUNCDECL_RPL (pthread_cond_destroy, int, (pthread_cond_t *cond)
1687 _GL_ARG_NONNULL ((1)));
1688_GL_CXXALIAS_RPL (pthread_cond_destroy, int, (pthread_cond_t *cond));
1689# else
1690# if !@HAVE_PTHREAD_COND_DESTROY@
1691_GL_FUNCDECL_SYS (pthread_cond_destroy, int, (pthread_cond_t *cond)
1692 _GL_ARG_NONNULL ((1)));
1693# endif
1694_GL_CXXALIAS_SYS (pthread_cond_destroy, int, (pthread_cond_t *cond));
1695# endif
1696# if __GLIBC__ >= 2
1697_GL_CXXALIASWARN (pthread_cond_destroy);
1698# endif
1699#elif defined GNULIB_POSIXCHECK
1700# undef pthread_cond_destroy
1701# if HAVE_RAW_DECL_PTHREAD_COND_DESTROY
1702_GL_WARN_ON_USE (pthread_cond_destroy, "pthread_cond_destroy is not portable - "
1703 "use gnulib module pthread-cond for portability");
1704# endif
1705#endif
1706
1707/* =========== Thread-specific storage functions =========== */
1708
1709#if @GNULIB_PTHREAD_TSS@
1710# if @REPLACE_PTHREAD_KEY_CREATE@
1711# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1712# undef pthread_key_create
1713# define pthread_key_create rpl_pthread_key_create
1714# endif
1715_GL_FUNCDECL_RPL (pthread_key_create, int,
1716 (pthread_key_t *keyp, void (*destructor) (void *))
1717 _GL_ARG_NONNULL ((1)));
1718_GL_CXXALIAS_RPL (pthread_key_create, int,
1719 (pthread_key_t *keyp, void (*destructor) (void *)));
1720# else
1721# if !@HAVE_PTHREAD_KEY_CREATE@
1722_GL_FUNCDECL_SYS (pthread_key_create, int,
1723 (pthread_key_t *keyp, void (*destructor) (void *))
1724 _GL_ARG_NONNULL ((1)));
1725# endif
1726_GL_CXXALIAS_SYS_CAST (pthread_key_create, int,
1727 (pthread_key_t *keyp, void (*destructor) (void *)));
1728# endif
1729# if __GLIBC__ >= 2
1730_GL_CXXALIASWARN (pthread_key_create);
1731# endif
1732#elif defined GNULIB_POSIXCHECK
1733# undef pthread_key_create
1734# if HAVE_RAW_DECL_PTHREAD_KEY_CREATE
1735_GL_WARN_ON_USE (pthread_key_create, "pthread_key_create is not portable - "
1736 "use gnulib module pthread-tss for portability");
1737# endif
1738#endif
1739
1740#if @GNULIB_PTHREAD_TSS@
1741# if @REPLACE_PTHREAD_SETSPECIFIC@
1742# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1743# undef pthread_setspecific
1744# define pthread_setspecific rpl_pthread_setspecific
1745# endif
1746_GL_FUNCDECL_RPL (pthread_setspecific, int,
1747 (pthread_key_t key, const void *value));
1748_GL_CXXALIAS_RPL (pthread_setspecific, int,
1749 (pthread_key_t key, const void *value));
1750# else
1751# if !@HAVE_PTHREAD_SETSPECIFIC@
1752_GL_FUNCDECL_SYS (pthread_setspecific, int,
1753 (pthread_key_t key, const void *value));
1754# endif
1755_GL_CXXALIAS_SYS (pthread_setspecific, int,
1756 (pthread_key_t key, const void *value));
1757# endif
1758# if __GLIBC__ >= 2
1759_GL_CXXALIASWARN (pthread_setspecific);
1760# endif
1761#elif defined GNULIB_POSIXCHECK
1762# undef pthread_setspecific
1763# if HAVE_RAW_DECL_PTHREAD_SETSPECIFIC
1764_GL_WARN_ON_USE (pthread_setspecific, "pthread_setspecific is not portable - "
1765 "use gnulib module pthread-tss for portability");
1766# endif
1767#endif
1768
1769#if @GNULIB_PTHREAD_TSS@
1770# if @REPLACE_PTHREAD_GETSPECIFIC@
1771# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1772# undef pthread_getspecific
1773# define pthread_getspecific rpl_pthread_getspecific
1774# endif
1775_GL_FUNCDECL_RPL (pthread_getspecific, void *, (pthread_key_t key));
1776_GL_CXXALIAS_RPL (pthread_getspecific, void *, (pthread_key_t key));
1777# else
1778# if !@HAVE_PTHREAD_GETSPECIFIC@
1779_GL_FUNCDECL_SYS (pthread_getspecific, void *, (pthread_key_t key));
1780# endif
1781_GL_CXXALIAS_SYS (pthread_getspecific, void *, (pthread_key_t key));
1782# endif
1783# if __GLIBC__ >= 2
1784_GL_CXXALIASWARN (pthread_getspecific);
1785# endif
1786#elif defined GNULIB_POSIXCHECK
1787# undef pthread_getspecific
1788# if HAVE_RAW_DECL_PTHREAD_GETSPECIFIC
1789_GL_WARN_ON_USE (pthread_getspecific, "pthread_getspecific is not portable - "
1790 "use gnulib module pthread-tss for portability");
1791# endif
1792#endif
1793
1794#if @GNULIB_PTHREAD_TSS@
1795# if @REPLACE_PTHREAD_KEY_DELETE@
1796# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1797# undef pthread_key_delete
1798# define pthread_key_delete rpl_pthread_key_delete
1799# endif
1800_GL_FUNCDECL_RPL (pthread_key_delete, int, (pthread_key_t key));
1801_GL_CXXALIAS_RPL (pthread_key_delete, int, (pthread_key_t key));
1802# else
1803# if !@HAVE_PTHREAD_KEY_DELETE@
1804_GL_FUNCDECL_SYS (pthread_key_delete, int, (pthread_key_t key));
1805# endif
1806_GL_CXXALIAS_SYS (pthread_key_delete, int, (pthread_key_t key));
1807# endif
1808# if __GLIBC__ >= 2
1809_GL_CXXALIASWARN (pthread_key_delete);
1810# endif
1811#elif defined GNULIB_POSIXCHECK
1812# undef pthread_key_delete
1813# if HAVE_RAW_DECL_PTHREAD_KEY_DELETE
1814_GL_WARN_ON_USE (pthread_key_delete, "pthread_key_delete is not portable - "
1815 "use gnulib module pthread-tss for portability");
1816# endif
1817#endif
1818
1819/* =========== Spinlock functions =========== */
1820
1821#if @GNULIB_PTHREAD_SPIN@
1822# if @REPLACE_PTHREAD_SPIN_INIT@
1823# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1824# undef pthread_spin_init
1825# define pthread_spin_init rpl_pthread_spin_init
1826# endif
1827_GL_FUNCDECL_RPL (pthread_spin_init, int,
1828 (pthread_spinlock_t *lock, int shared_across_processes)
1829 _GL_ARG_NONNULL ((1)));
1830_GL_CXXALIAS_RPL (pthread_spin_init, int,
1831 (pthread_spinlock_t *lock, int shared_across_processes));
1832# else
1833# if !@HAVE_PTHREAD_SPIN_INIT@
1834_GL_FUNCDECL_SYS (pthread_spin_init, int,
1835 (pthread_spinlock_t *lock, int shared_across_processes)
1836 _GL_ARG_NONNULL ((1)));
1837# endif
1838_GL_CXXALIAS_SYS (pthread_spin_init, int,
1839 (pthread_spinlock_t *lock, int shared_across_processes));
1840# endif
1841# if __GLIBC__ >= 2
1842_GL_CXXALIASWARN (pthread_spin_init);
1843# endif
1844#elif defined GNULIB_POSIXCHECK
1845# undef pthread_spin_init
1846# if HAVE_RAW_DECL_PTHREAD_SPIN_INIT
1847_GL_WARN_ON_USE (pthread_spin_init, "pthread_spin_init is not portable - "
1848 "use gnulib module pthread-spin for portability");
1849# endif
1850#endif
1851
1852#if @GNULIB_PTHREAD_SPIN@
1853# if @REPLACE_PTHREAD_SPIN_LOCK@
1854# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1855# undef pthread_spin_lock
1856# define pthread_spin_lock rpl_pthread_spin_lock
1857# endif
1858_GL_FUNCDECL_RPL (pthread_spin_lock, int, (pthread_spinlock_t *lock)
1859 _GL_ARG_NONNULL ((1)));
1860_GL_CXXALIAS_RPL (pthread_spin_lock, int, (pthread_spinlock_t *lock));
1861# else
1862# if !@HAVE_PTHREAD_SPIN_LOCK@
1863_GL_FUNCDECL_SYS (pthread_spin_lock, int, (pthread_spinlock_t *lock)
1864 _GL_ARG_NONNULL ((1)));
1865# endif
1866_GL_CXXALIAS_SYS (pthread_spin_lock, int, (pthread_spinlock_t *lock));
1867# endif
1868# if __GLIBC__ >= 2
1869_GL_CXXALIASWARN (pthread_spin_lock);
1870# endif
1871#elif defined GNULIB_POSIXCHECK
1872# undef pthread_spin_lock
1873# if HAVE_RAW_DECL_PTHREAD_SPIN_LOCK
1874_GL_WARN_ON_USE (pthread_spin_lock, "pthread_spin_lock is not portable - "
1875 "use gnulib module pthread-spin for portability");
1876# endif
1877#endif
1878
1879#if @GNULIB_PTHREAD_SPIN@
1880# if @REPLACE_PTHREAD_SPIN_TRYLOCK@
1881# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1882# undef pthread_spin_trylock
1883# define pthread_spin_trylock rpl_pthread_spin_trylock
1884# endif
1885_GL_FUNCDECL_RPL (pthread_spin_trylock, int, (pthread_spinlock_t *lock)
1886 _GL_ARG_NONNULL ((1)));
1887_GL_CXXALIAS_RPL (pthread_spin_trylock, int, (pthread_spinlock_t *lock));
1888# else
1889# if !@HAVE_PTHREAD_SPIN_TRYLOCK@
1890_GL_FUNCDECL_SYS (pthread_spin_trylock, int, (pthread_spinlock_t *lock)
1891 _GL_ARG_NONNULL ((1)));
1892# endif
1893_GL_CXXALIAS_SYS (pthread_spin_trylock, int, (pthread_spinlock_t *lock));
1894# endif
1895# if __GLIBC__ >= 2
1896_GL_CXXALIASWARN (pthread_spin_trylock);
1897# endif
1898#elif defined GNULIB_POSIXCHECK
1899# undef pthread_spin_trylock
1900# if HAVE_RAW_DECL_PTHREAD_SPIN_TRYLOCK
1901_GL_WARN_ON_USE (pthread_spin_trylock, "pthread_spin_trylock is not portable - "
1902 "use gnulib module pthread-spin for portability");
1903# endif
1904#endif
1905
1906#if @GNULIB_PTHREAD_SPIN@
1907# if @REPLACE_PTHREAD_SPIN_UNLOCK@
1908# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1909# undef pthread_spin_unlock
1910# define pthread_spin_unlock rpl_pthread_spin_unlock
1911# endif
1912_GL_FUNCDECL_RPL (pthread_spin_unlock, int, (pthread_spinlock_t *lock)
1913 _GL_ARG_NONNULL ((1)));
1914_GL_CXXALIAS_RPL (pthread_spin_unlock, int, (pthread_spinlock_t *lock));
1915# else
1916# if !@HAVE_PTHREAD_SPIN_UNLOCK@
1917_GL_FUNCDECL_SYS (pthread_spin_unlock, int, (pthread_spinlock_t *lock)
1918 _GL_ARG_NONNULL ((1)));
1919# endif
1920_GL_CXXALIAS_SYS (pthread_spin_unlock, int, (pthread_spinlock_t *lock));
1921# endif
1922# if __GLIBC__ >= 2
1923_GL_CXXALIASWARN (pthread_spin_unlock);
1924# endif
1925#elif defined GNULIB_POSIXCHECK
1926# undef pthread_spin_unlock
1927# if HAVE_RAW_DECL_PTHREAD_SPIN_UNLOCK
1928_GL_WARN_ON_USE (pthread_spin_unlock, "pthread_spin_unlock is not portable - "
1929 "use gnulib module pthread-spin for portability");
1930# endif
1931#endif
1932
1933#if @GNULIB_PTHREAD_SPIN@
1934# if @REPLACE_PTHREAD_SPIN_DESTROY@
1935# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1936# undef pthread_spin_destroy
1937# define pthread_spin_destroy rpl_pthread_spin_destroy
1938# endif
1939_GL_FUNCDECL_RPL (pthread_spin_destroy, int, (pthread_spinlock_t *lock)
1940 _GL_ARG_NONNULL ((1)));
1941_GL_CXXALIAS_RPL (pthread_spin_destroy, int, (pthread_spinlock_t *lock));
1942# else
1943# if !@HAVE_PTHREAD_SPIN_DESTROY@
1944_GL_FUNCDECL_SYS (pthread_spin_destroy, int, (pthread_spinlock_t *lock)
1945 _GL_ARG_NONNULL ((1)));
1946# endif
1947_GL_CXXALIAS_SYS (pthread_spin_destroy, int, (pthread_spinlock_t *lock));
1948# endif
1949# if __GLIBC__ >= 2
1950_GL_CXXALIASWARN (pthread_spin_destroy);
1951# endif
1952#elif defined GNULIB_POSIXCHECK
1953# undef pthread_spin_destroy
1954# if HAVE_RAW_DECL_PTHREAD_SPIN_DESTROY
1955_GL_WARN_ON_USE (pthread_spin_destroy, "pthread_spin_destroy is not portable - "
1956 "use gnulib module pthread-spin for portability");
1957# endif
1958#endif
1959
1960
1961#endif /* _@GUARD_PREFIX@_PTHREAD_H_ */
1962#endif /* _@GUARD_PREFIX@_PTHREAD_H_ */
1963#endif
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette