spawn.h revision 05436638acc7c010349a69c3395f1a57c642dc62
1/* DO NOT EDIT! GENERATED AUTOMATICALLY! */ 2/* Definitions for POSIX spawn interface. 3 Copyright (C) 2000, 2003-2004, 2008-2012 Free Software Foundation, Inc. 4 This file is part of the GNU C Library. 5 6 This program is free software: you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 18 19#ifndef _GL_SPAWN_H 20 21#if __GNUC__ >= 3 22#pragma GCC system_header 23#endif 24 25 26/* The include_next requires a split double-inclusion guard. */ 27#if 1 28# include_next <spawn.h> 29#endif 30 31#ifndef _GL_SPAWN_H 32#define _GL_SPAWN_H 33 34/* Get definitions of 'struct sched_param' and 'sigset_t'. 35 But avoid namespace pollution on glibc systems. */ 36#if !(defined __GLIBC__ && !defined __UCLIBC__) 37# include <sched.h> 38# include <signal.h> 39#endif 40 41#include <sys/types.h> 42 43#ifndef __THROW 44# define __THROW 45#endif 46 47/* GCC 2.95 and later have "__restrict"; C99 compilers have 48 "restrict", and "configure" may have defined "restrict". 49 Other compilers use __restrict, __restrict__, and _Restrict, and 50 'configure' might #define 'restrict' to those words, so pick a 51 different name. */ 52#ifndef _Restrict_ 53# if 199901L <= __STDC_VERSION__ 54# define _Restrict_ restrict 55# elif 2 < __GNUC__ || (2 == __GNUC__ && 95 <= __GNUC_MINOR__) 56# define _Restrict_ __restrict 57# else 58# define _Restrict_ 59# endif 60#endif 61/* gcc 3.1 and up support the [restrict] syntax. Don't trust 62 sys/cdefs.h's definition of __restrict_arr, though, as it 63 mishandles gcc -ansi -pedantic. */ 64#ifndef _Restrict_arr_ 65# if ((199901L <= __STDC_VERSION__ \ 66 || ((3 < __GNUC__ || (3 == __GNUC__ && 1 <= __GNUC_MINOR__)) \ 67 && !defined __STRICT_ANSI__)) \ 68 && !defined __GNUG__) 69# define _Restrict_arr_ _Restrict_ 70# else 71# define _Restrict_arr_ 72# endif 73#endif 74 75/* The definitions of _GL_FUNCDECL_RPL etc. are copied here. */ 76#ifndef _GL_CXXDEFS_H 77#define _GL_CXXDEFS_H 78 79/* The three most frequent use cases of these macros are: 80 81 * For providing a substitute for a function that is missing on some 82 platforms, but is declared and works fine on the platforms on which 83 it exists: 84 85 #if @GNULIB_FOO@ 86 # if !@HAVE_FOO@ 87 _GL_FUNCDECL_SYS (foo, ...); 88 # endif 89 _GL_CXXALIAS_SYS (foo, ...); 90 _GL_CXXALIASWARN (foo); 91 #elif defined GNULIB_POSIXCHECK 92 ... 93 #endif 94 95 * For providing a replacement for a function that exists on all platforms, 96 but is broken/insufficient and needs to be replaced on some platforms: 97 98 #if @GNULIB_FOO@ 99 # if @REPLACE_FOO@ 100 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 101 # undef foo 102 # define foo rpl_foo 103 # endif 104 _GL_FUNCDECL_RPL (foo, ...); 105 _GL_CXXALIAS_RPL (foo, ...); 106 # else 107 _GL_CXXALIAS_SYS (foo, ...); 108 # endif 109 _GL_CXXALIASWARN (foo); 110 #elif defined GNULIB_POSIXCHECK 111 ... 112 #endif 113 114 * For providing a replacement for a function that exists on some platforms 115 but is broken/insufficient and needs to be replaced on some of them and 116 is additionally either missing or undeclared on some other platforms: 117 118 #if @GNULIB_FOO@ 119 # if @REPLACE_FOO@ 120 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 121 # undef foo 122 # define foo rpl_foo 123 # endif 124 _GL_FUNCDECL_RPL (foo, ...); 125 _GL_CXXALIAS_RPL (foo, ...); 126 # else 127 # if !@HAVE_FOO@ or if !@HAVE_DECL_FOO@ 128 _GL_FUNCDECL_SYS (foo, ...); 129 # endif 130 _GL_CXXALIAS_SYS (foo, ...); 131 # endif 132 _GL_CXXALIASWARN (foo); 133 #elif defined GNULIB_POSIXCHECK 134 ... 135 #endif 136*/ 137 138/* _GL_EXTERN_C declaration; 139 performs the declaration with C linkage. */ 140#if defined __cplusplus 141# define _GL_EXTERN_C extern "C" 142#else 143# define _GL_EXTERN_C extern 144#endif 145 146/* _GL_FUNCDECL_RPL (func, rettype, parameters_and_attributes); 147 declares a replacement function, named rpl_func, with the given prototype, 148 consisting of return type, parameters, and attributes. 149 Example: 150 _GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...) 151 _GL_ARG_NONNULL ((1))); 152 */ 153#define _GL_FUNCDECL_RPL(func,rettype,parameters_and_attributes) \ 154 _GL_FUNCDECL_RPL_1 (rpl_##func, rettype, parameters_and_attributes) 155#define _GL_FUNCDECL_RPL_1(rpl_func,rettype,parameters_and_attributes) \ 156 _GL_EXTERN_C rettype rpl_func parameters_and_attributes 157 158/* _GL_FUNCDECL_SYS (func, rettype, parameters_and_attributes); 159 declares the system function, named func, with the given prototype, 160 consisting of return type, parameters, and attributes. 161 Example: 162 _GL_FUNCDECL_SYS (open, int, (const char *filename, int flags, ...) 163 _GL_ARG_NONNULL ((1))); 164 */ 165#define _GL_FUNCDECL_SYS(func,rettype,parameters_and_attributes) \ 166 _GL_EXTERN_C rettype func parameters_and_attributes 167 168/* _GL_CXXALIAS_RPL (func, rettype, parameters); 169 declares a C++ alias called GNULIB_NAMESPACE::func 170 that redirects to rpl_func, if GNULIB_NAMESPACE is defined. 171 Example: 172 _GL_CXXALIAS_RPL (open, int, (const char *filename, int flags, ...)); 173 */ 174#define _GL_CXXALIAS_RPL(func,rettype,parameters) \ 175 _GL_CXXALIAS_RPL_1 (func, rpl_##func, rettype, parameters) 176#if defined __cplusplus && defined GNULIB_NAMESPACE 177# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \ 178 namespace GNULIB_NAMESPACE \ 179 { \ 180 rettype (*const func) parameters = ::rpl_func; \ 181 } \ 182 _GL_EXTERN_C int _gl_cxxalias_dummy 183#else 184# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \ 185 _GL_EXTERN_C int _gl_cxxalias_dummy 186#endif 187 188/* _GL_CXXALIAS_RPL_CAST_1 (func, rpl_func, rettype, parameters); 189 is like _GL_CXXALIAS_RPL_1 (func, rpl_func, rettype, parameters); 190 except that the C function rpl_func may have a slightly different 191 declaration. A cast is used to silence the "invalid conversion" error 192 that would otherwise occur. */ 193#if defined __cplusplus && defined GNULIB_NAMESPACE 194# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \ 195 namespace GNULIB_NAMESPACE \ 196 { \ 197 rettype (*const func) parameters = \ 198 reinterpret_cast<rettype(*)parameters>(::rpl_func); \ 199 } \ 200 _GL_EXTERN_C int _gl_cxxalias_dummy 201#else 202# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \ 203 _GL_EXTERN_C int _gl_cxxalias_dummy 204#endif 205 206/* _GL_CXXALIAS_SYS (func, rettype, parameters); 207 declares a C++ alias called GNULIB_NAMESPACE::func 208 that redirects to the system provided function func, if GNULIB_NAMESPACE 209 is defined. 210 Example: 211 _GL_CXXALIAS_SYS (open, int, (const char *filename, int flags, ...)); 212 */ 213#if defined __cplusplus && defined GNULIB_NAMESPACE 214 /* If we were to write 215 rettype (*const func) parameters = ::func; 216 like above in _GL_CXXALIAS_RPL_1, the compiler could optimize calls 217 better (remove an indirection through a 'static' pointer variable), 218 but then the _GL_CXXALIASWARN macro below would cause a warning not only 219 for uses of ::func but also for uses of GNULIB_NAMESPACE::func. */ 220# define _GL_CXXALIAS_SYS(func,rettype,parameters) \ 221 namespace GNULIB_NAMESPACE \ 222 { \ 223 static rettype (*func) parameters = ::func; \ 224 } \ 225 _GL_EXTERN_C int _gl_cxxalias_dummy 226#else 227# define _GL_CXXALIAS_SYS(func,rettype,parameters) \ 228 _GL_EXTERN_C int _gl_cxxalias_dummy 229#endif 230 231/* _GL_CXXALIAS_SYS_CAST (func, rettype, parameters); 232 is like _GL_CXXALIAS_SYS (func, rettype, parameters); 233 except that the C function func may have a slightly different declaration. 234 A cast is used to silence the "invalid conversion" error that would 235 otherwise occur. */ 236#if defined __cplusplus && defined GNULIB_NAMESPACE 237# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \ 238 namespace GNULIB_NAMESPACE \ 239 { \ 240 static rettype (*func) parameters = \ 241 reinterpret_cast<rettype(*)parameters>(::func); \ 242 } \ 243 _GL_EXTERN_C int _gl_cxxalias_dummy 244#else 245# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \ 246 _GL_EXTERN_C int _gl_cxxalias_dummy 247#endif 248 249/* _GL_CXXALIAS_SYS_CAST2 (func, rettype, parameters, rettype2, parameters2); 250 is like _GL_CXXALIAS_SYS (func, rettype, parameters); 251 except that the C function is picked among a set of overloaded functions, 252 namely the one with rettype2 and parameters2. Two consecutive casts 253 are used to silence the "cannot find a match" and "invalid conversion" 254 errors that would otherwise occur. */ 255#if defined __cplusplus && defined GNULIB_NAMESPACE 256 /* The outer cast must be a reinterpret_cast. 257 The inner cast: When the function is defined as a set of overloaded 258 functions, it works as a static_cast<>, choosing the designated variant. 259 When the function is defined as a single variant, it works as a 260 reinterpret_cast<>. The parenthesized cast syntax works both ways. */ 261# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \ 262 namespace GNULIB_NAMESPACE \ 263 { \ 264 static rettype (*func) parameters = \ 265 reinterpret_cast<rettype(*)parameters>( \ 266 (rettype2(*)parameters2)(::func)); \ 267 } \ 268 _GL_EXTERN_C int _gl_cxxalias_dummy 269#else 270# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \ 271 _GL_EXTERN_C int _gl_cxxalias_dummy 272#endif 273 274/* _GL_CXXALIASWARN (func); 275 causes a warning to be emitted when ::func is used but not when 276 GNULIB_NAMESPACE::func is used. func must be defined without overloaded 277 variants. */ 278#if defined __cplusplus && defined GNULIB_NAMESPACE 279# define _GL_CXXALIASWARN(func) \ 280 _GL_CXXALIASWARN_1 (func, GNULIB_NAMESPACE) 281# define _GL_CXXALIASWARN_1(func,namespace) \ 282 _GL_CXXALIASWARN_2 (func, namespace) 283/* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>, 284 we enable the warning only when not optimizing. */ 285# if !__OPTIMIZE__ 286# define _GL_CXXALIASWARN_2(func,namespace) \ 287 _GL_WARN_ON_USE (func, \ 288 "The symbol ::" #func " refers to the system function. " \ 289 "Use " #namespace "::" #func " instead.") 290# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 291# define _GL_CXXALIASWARN_2(func,namespace) \ 292 extern __typeof__ (func) func 293# else 294# define _GL_CXXALIASWARN_2(func,namespace) \ 295 _GL_EXTERN_C int _gl_cxxalias_dummy 296# endif 297#else 298# define _GL_CXXALIASWARN(func) \ 299 _GL_EXTERN_C int _gl_cxxalias_dummy 300#endif 301 302/* _GL_CXXALIASWARN1 (func, rettype, parameters_and_attributes); 303 causes a warning to be emitted when the given overloaded variant of ::func 304 is used but not when GNULIB_NAMESPACE::func is used. */ 305#if defined __cplusplus && defined GNULIB_NAMESPACE 306# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \ 307 _GL_CXXALIASWARN1_1 (func, rettype, parameters_and_attributes, \ 308 GNULIB_NAMESPACE) 309# define _GL_CXXALIASWARN1_1(func,rettype,parameters_and_attributes,namespace) \ 310 _GL_CXXALIASWARN1_2 (func, rettype, parameters_and_attributes, namespace) 311/* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>, 312 we enable the warning only when not optimizing. */ 313# if !__OPTIMIZE__ 314# define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \ 315 _GL_WARN_ON_USE_CXX (func, rettype, parameters_and_attributes, \ 316 "The symbol ::" #func " refers to the system function. " \ 317 "Use " #namespace "::" #func " instead.") 318# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 319# define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \ 320 extern __typeof__ (func) func 321# else 322# define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \ 323 _GL_EXTERN_C int _gl_cxxalias_dummy 324# endif 325#else 326# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \ 327 _GL_EXTERN_C int _gl_cxxalias_dummy 328#endif 329 330#endif /* _GL_CXXDEFS_H */ 331 332/* The definition of _GL_ARG_NONNULL is copied here. */ 333/* _GL_ARG_NONNULL((n,...,m)) tells the compiler and static analyzer tools 334 that the values passed as arguments n, ..., m must be non-NULL pointers. 335 n = 1 stands for the first argument, n = 2 for the second argument etc. */ 336#ifndef _GL_ARG_NONNULL 337# if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || __GNUC__ > 3 338# define _GL_ARG_NONNULL(params) __attribute__ ((__nonnull__ params)) 339# else 340# define _GL_ARG_NONNULL(params) 341# endif 342#endif 343 344/* The definition of _GL_WARN_ON_USE is copied here. */ 345#ifndef _GL_WARN_ON_USE 346 347# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__) 348/* A compiler attribute is available in gcc versions 4.3.0 and later. */ 349# define _GL_WARN_ON_USE(function, message) \ 350extern __typeof__ (function) function __attribute__ ((__warning__ (message))) 351# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 352/* Verify the existence of the function. */ 353# define _GL_WARN_ON_USE(function, message) \ 354extern __typeof__ (function) function 355# else /* Unsupported. */ 356# define _GL_WARN_ON_USE(function, message) \ 357_GL_WARN_EXTERN_C int _gl_warn_on_use 358# endif 359#endif 360 361/* _GL_WARN_ON_USE_CXX (function, rettype, parameters_and_attributes, "string") 362 is like _GL_WARN_ON_USE (function, "string"), except that the function is 363 declared with the given prototype, consisting of return type, parameters, 364 and attributes. 365 This variant is useful for overloaded functions in C++. _GL_WARN_ON_USE does 366 not work in this case. */ 367#ifndef _GL_WARN_ON_USE_CXX 368# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__) 369# define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \ 370extern rettype function parameters_and_attributes \ 371 __attribute__ ((__warning__ (msg))) 372# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 373/* Verify the existence of the function. */ 374# define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \ 375extern rettype function parameters_and_attributes 376# else /* Unsupported. */ 377# define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \ 378_GL_WARN_EXTERN_C int _gl_warn_on_use 379# endif 380#endif 381 382/* _GL_WARN_EXTERN_C declaration; 383 performs the declaration with C linkage. */ 384#ifndef _GL_WARN_EXTERN_C 385# if defined __cplusplus 386# define _GL_WARN_EXTERN_C extern "C" 387# else 388# define _GL_WARN_EXTERN_C extern 389# endif 390#endif 391 392 393/* Data structure to contain attributes for thread creation. */ 394#if 0 395# define posix_spawnattr_t rpl_posix_spawnattr_t 396#endif 397#if 0 || !1 398# if !GNULIB_defined_posix_spawnattr_t 399typedef struct 400{ 401 short int _flags; 402 pid_t _pgrp; 403 sigset_t _sd; 404 sigset_t _ss; 405 struct sched_param _sp; 406 int _policy; 407 int __pad[16]; 408} posix_spawnattr_t; 409# define GNULIB_defined_posix_spawnattr_t 1 410# endif 411#endif 412 413 414/* Data structure to contain information about the actions to be 415 performed in the new process with respect to file descriptors. */ 416#if 0 417# define posix_spawn_file_actions_t rpl_posix_spawn_file_actions_t 418#endif 419#if 0 || !1 420# if !GNULIB_defined_posix_spawn_file_actions_t 421typedef struct 422{ 423 int _allocated; 424 int _used; 425 struct __spawn_action *_actions; 426 int __pad[16]; 427} posix_spawn_file_actions_t; 428# define GNULIB_defined_posix_spawn_file_actions_t 1 429# endif 430#endif 431 432 433/* Flags to be set in the 'posix_spawnattr_t'. */ 434#if 1 435/* Use the values from the system, but provide the missing ones. */ 436# ifndef POSIX_SPAWN_SETSCHEDPARAM 437# define POSIX_SPAWN_SETSCHEDPARAM 0 438# endif 439# ifndef POSIX_SPAWN_SETSCHEDULER 440# define POSIX_SPAWN_SETSCHEDULER 0 441# endif 442#else 443# if 0 444/* Use the values from the system, for better compatibility. */ 445/* But this implementation does not support AIX extensions. */ 446# undef POSIX_SPAWN_FORK_HANDLERS 447# else 448# define POSIX_SPAWN_RESETIDS 0x01 449# define POSIX_SPAWN_SETPGROUP 0x02 450# define POSIX_SPAWN_SETSIGDEF 0x04 451# define POSIX_SPAWN_SETSIGMASK 0x08 452# define POSIX_SPAWN_SETSCHEDPARAM 0x10 453# define POSIX_SPAWN_SETSCHEDULER 0x20 454# endif 455#endif 456/* A GNU extension. Use the next free bit position. */ 457#define POSIX_SPAWN_USEVFORK \ 458 ((POSIX_SPAWN_RESETIDS | (POSIX_SPAWN_RESETIDS - 1) \ 459 | POSIX_SPAWN_SETPGROUP | (POSIX_SPAWN_SETPGROUP - 1) \ 460 | POSIX_SPAWN_SETSIGDEF | (POSIX_SPAWN_SETSIGDEF - 1) \ 461 | POSIX_SPAWN_SETSIGMASK | (POSIX_SPAWN_SETSIGMASK - 1) \ 462 | POSIX_SPAWN_SETSCHEDPARAM \ 463 | (POSIX_SPAWN_SETSCHEDPARAM > 0 ? POSIX_SPAWN_SETSCHEDPARAM - 1 : 0) \ 464 | POSIX_SPAWN_SETSCHEDULER \ 465 | (POSIX_SPAWN_SETSCHEDULER > 0 ? POSIX_SPAWN_SETSCHEDULER - 1 : 0)) \ 466 + 1) 467#if !GNULIB_defined_verify_POSIX_SPAWN_USEVFORK_no_overlap 468typedef int verify_POSIX_SPAWN_USEVFORK_no_overlap 469 [(((POSIX_SPAWN_RESETIDS | POSIX_SPAWN_SETPGROUP 470 | POSIX_SPAWN_SETSIGDEF | POSIX_SPAWN_SETSIGMASK 471 | POSIX_SPAWN_SETSCHEDPARAM | POSIX_SPAWN_SETSCHEDULER) 472 & POSIX_SPAWN_USEVFORK) 473 == 0) 474 ? 1 : -1]; 475# define GNULIB_defined_verify_POSIX_SPAWN_USEVFORK_no_overlap 1 476#endif 477 478 479#if 0 480/* Spawn a new process executing PATH with the attributes describes in *ATTRP. 481 Before running the process perform the actions described in FILE-ACTIONS. 482 483 This function is a possible cancellation points and therefore not 484 marked with __THROW. */ 485# if 0 486# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 487# define posix_spawn rpl_posix_spawn 488# endif 489_GL_FUNCDECL_RPL (posix_spawn, int, 490 (pid_t *_Restrict_ __pid, 491 const char *_Restrict_ __path, 492 const posix_spawn_file_actions_t *_Restrict_ __file_actions, 493 const posix_spawnattr_t *_Restrict_ __attrp, 494 char *const argv[_Restrict_arr_], 495 char *const envp[_Restrict_arr_]) 496 _GL_ARG_NONNULL ((2, 5, 6))); 497_GL_CXXALIAS_RPL (posix_spawn, int, 498 (pid_t *_Restrict_ __pid, 499 const char *_Restrict_ __path, 500 const posix_spawn_file_actions_t *_Restrict_ __file_actions, 501 const posix_spawnattr_t *_Restrict_ __attrp, 502 char *const argv[_Restrict_arr_], 503 char *const envp[_Restrict_arr_])); 504# else 505# if !1 506_GL_FUNCDECL_SYS (posix_spawn, int, 507 (pid_t *_Restrict_ __pid, 508 const char *_Restrict_ __path, 509 const posix_spawn_file_actions_t *_Restrict_ __file_actions, 510 const posix_spawnattr_t *_Restrict_ __attrp, 511 char *const argv[_Restrict_arr_], 512 char *const envp[_Restrict_arr_]) 513 _GL_ARG_NONNULL ((2, 5, 6))); 514# endif 515_GL_CXXALIAS_SYS (posix_spawn, int, 516 (pid_t *_Restrict_ __pid, 517 const char *_Restrict_ __path, 518 const posix_spawn_file_actions_t *_Restrict_ __file_actions, 519 const posix_spawnattr_t *_Restrict_ __attrp, 520 char *const argv[_Restrict_arr_], 521 char *const envp[_Restrict_arr_])); 522# endif 523_GL_CXXALIASWARN (posix_spawn); 524#elif defined GNULIB_POSIXCHECK 525# undef posix_spawn 526# if HAVE_RAW_DECL_POSIX_SPAWN 527_GL_WARN_ON_USE (posix_spawn, "posix_spawn is unportable - " 528 "use gnulib module posix_spawn for portability"); 529# endif 530#endif 531 532#if 1 533/* Similar to 'posix_spawn' but search for FILE in the PATH. 534 535 This function is a possible cancellation points and therefore not 536 marked with __THROW. */ 537# if 0 538# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 539# define posix_spawnp rpl_posix_spawnp 540# endif 541_GL_FUNCDECL_RPL (posix_spawnp, int, 542 (pid_t *__pid, const char *__file, 543 const posix_spawn_file_actions_t *__file_actions, 544 const posix_spawnattr_t *__attrp, 545 char *const argv[], char *const envp[]) 546 _GL_ARG_NONNULL ((2, 5, 6))); 547_GL_CXXALIAS_RPL (posix_spawnp, int, 548 (pid_t *__pid, const char *__file, 549 const posix_spawn_file_actions_t *__file_actions, 550 const posix_spawnattr_t *__attrp, 551 char *const argv[], char *const envp[])); 552# else 553# if !1 554_GL_FUNCDECL_SYS (posix_spawnp, int, 555 (pid_t *__pid, const char *__file, 556 const posix_spawn_file_actions_t *__file_actions, 557 const posix_spawnattr_t *__attrp, 558 char *const argv[], char *const envp[]) 559 _GL_ARG_NONNULL ((2, 5, 6))); 560# endif 561_GL_CXXALIAS_SYS (posix_spawnp, int, 562 (pid_t *__pid, const char *__file, 563 const posix_spawn_file_actions_t *__file_actions, 564 const posix_spawnattr_t *__attrp, 565 char *const argv[], char *const envp[])); 566# endif 567_GL_CXXALIASWARN (posix_spawnp); 568#elif defined GNULIB_POSIXCHECK 569# undef posix_spawnp 570# if HAVE_RAW_DECL_POSIX_SPAWNP 571_GL_WARN_ON_USE (posix_spawnp, "posix_spawnp is unportable - " 572 "use gnulib module posix_spawnp for portability"); 573# endif 574#endif 575 576 577#if 1 578/* Initialize data structure with attributes for 'spawn' to default values. */ 579# if 0 580# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 581# define posix_spawnattr_init rpl_posix_spawnattr_init 582# endif 583_GL_FUNCDECL_RPL (posix_spawnattr_init, int, (posix_spawnattr_t *__attr) 584 __THROW _GL_ARG_NONNULL ((1))); 585_GL_CXXALIAS_RPL (posix_spawnattr_init, int, (posix_spawnattr_t *__attr)); 586# else 587# if !1 588_GL_FUNCDECL_SYS (posix_spawnattr_init, int, (posix_spawnattr_t *__attr) 589 __THROW _GL_ARG_NONNULL ((1))); 590# endif 591_GL_CXXALIAS_SYS (posix_spawnattr_init, int, (posix_spawnattr_t *__attr)); 592# endif 593_GL_CXXALIASWARN (posix_spawnattr_init); 594#elif defined GNULIB_POSIXCHECK 595# undef posix_spawnattr_init 596# if HAVE_RAW_DECL_POSIX_SPAWNATTR_INIT 597_GL_WARN_ON_USE (posix_spawnattr_init, "posix_spawnattr_init is unportable - " 598 "use gnulib module posix_spawnattr_init for portability"); 599# endif 600#endif 601 602#if 1 603/* Free resources associated with ATTR. */ 604# if 0 605# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 606# define posix_spawnattr_destroy rpl_posix_spawnattr_destroy 607# endif 608_GL_FUNCDECL_RPL (posix_spawnattr_destroy, int, (posix_spawnattr_t *__attr) 609 __THROW _GL_ARG_NONNULL ((1))); 610_GL_CXXALIAS_RPL (posix_spawnattr_destroy, int, (posix_spawnattr_t *__attr)); 611# else 612# if !1 613_GL_FUNCDECL_SYS (posix_spawnattr_destroy, int, (posix_spawnattr_t *__attr) 614 __THROW _GL_ARG_NONNULL ((1))); 615# endif 616_GL_CXXALIAS_SYS (posix_spawnattr_destroy, int, (posix_spawnattr_t *__attr)); 617# endif 618_GL_CXXALIASWARN (posix_spawnattr_destroy); 619#elif defined GNULIB_POSIXCHECK 620# undef posix_spawnattr_destroy 621# if HAVE_RAW_DECL_POSIX_SPAWNATTR_DESTROY 622_GL_WARN_ON_USE (posix_spawnattr_destroy, 623 "posix_spawnattr_destroy is unportable - " 624 "use gnulib module posix_spawnattr_destroy for portability"); 625# endif 626#endif 627 628#if 0 629/* Store signal mask for signals with default handling from ATTR in 630 SIGDEFAULT. */ 631# if 0 632# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 633# define posix_spawnattr_getsigdefault rpl_posix_spawnattr_getsigdefault 634# endif 635_GL_FUNCDECL_RPL (posix_spawnattr_getsigdefault, int, 636 (const posix_spawnattr_t *_Restrict_ __attr, 637 sigset_t *_Restrict_ __sigdefault) 638 __THROW _GL_ARG_NONNULL ((1, 2))); 639_GL_CXXALIAS_RPL (posix_spawnattr_getsigdefault, int, 640 (const posix_spawnattr_t *_Restrict_ __attr, 641 sigset_t *_Restrict_ __sigdefault)); 642# else 643# if !1 644_GL_FUNCDECL_SYS (posix_spawnattr_getsigdefault, int, 645 (const posix_spawnattr_t *_Restrict_ __attr, 646 sigset_t *_Restrict_ __sigdefault) 647 __THROW _GL_ARG_NONNULL ((1, 2))); 648# endif 649_GL_CXXALIAS_SYS (posix_spawnattr_getsigdefault, int, 650 (const posix_spawnattr_t *_Restrict_ __attr, 651 sigset_t *_Restrict_ __sigdefault)); 652# endif 653_GL_CXXALIASWARN (posix_spawnattr_getsigdefault); 654#elif defined GNULIB_POSIXCHECK 655# undef posix_spawnattr_getsigdefault 656# if HAVE_RAW_DECL_POSIX_SPAWNATTR_GETSIGDEFAULT 657_GL_WARN_ON_USE (posix_spawnattr_getsigdefault, 658 "posix_spawnattr_getsigdefault is unportable - " 659 "use gnulib module posix_spawnattr_getsigdefault for portability"); 660# endif 661#endif 662 663#if 0 664/* Set signal mask for signals with default handling in ATTR to SIGDEFAULT. */ 665# if 0 666# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 667# define posix_spawnattr_setsigdefault rpl_posix_spawnattr_setsigdefault 668# endif 669_GL_FUNCDECL_RPL (posix_spawnattr_setsigdefault, int, 670 (posix_spawnattr_t *_Restrict_ __attr, 671 const sigset_t *_Restrict_ __sigdefault) 672 __THROW _GL_ARG_NONNULL ((1, 2))); 673_GL_CXXALIAS_RPL (posix_spawnattr_setsigdefault, int, 674 (posix_spawnattr_t *_Restrict_ __attr, 675 const sigset_t *_Restrict_ __sigdefault)); 676# else 677# if !1 678_GL_FUNCDECL_SYS (posix_spawnattr_setsigdefault, int, 679 (posix_spawnattr_t *_Restrict_ __attr, 680 const sigset_t *_Restrict_ __sigdefault) 681 __THROW _GL_ARG_NONNULL ((1, 2))); 682# endif 683_GL_CXXALIAS_SYS (posix_spawnattr_setsigdefault, int, 684 (posix_spawnattr_t *_Restrict_ __attr, 685 const sigset_t *_Restrict_ __sigdefault)); 686# endif 687_GL_CXXALIASWARN (posix_spawnattr_setsigdefault); 688#elif defined GNULIB_POSIXCHECK 689# undef posix_spawnattr_setsigdefault 690# if HAVE_RAW_DECL_POSIX_SPAWNATTR_SETSIGDEFAULT 691_GL_WARN_ON_USE (posix_spawnattr_setsigdefault, 692 "posix_spawnattr_setsigdefault is unportable - " 693 "use gnulib module posix_spawnattr_setsigdefault for portability"); 694# endif 695#endif 696 697#if 0 698/* Store signal mask for the new process from ATTR in SIGMASK. */ 699# if 0 700# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 701# define posix_spawnattr_getsigmask rpl_posix_spawnattr_getsigmask 702# endif 703_GL_FUNCDECL_RPL (posix_spawnattr_getsigmask, int, 704 (const posix_spawnattr_t *_Restrict_ __attr, 705 sigset_t *_Restrict_ __sigmask) 706 __THROW _GL_ARG_NONNULL ((1, 2))); 707_GL_CXXALIAS_RPL (posix_spawnattr_getsigmask, int, 708 (const posix_spawnattr_t *_Restrict_ __attr, 709 sigset_t *_Restrict_ __sigmask)); 710# else 711# if !1 712_GL_FUNCDECL_SYS (posix_spawnattr_getsigmask, int, 713 (const posix_spawnattr_t *_Restrict_ __attr, 714 sigset_t *_Restrict_ __sigmask) 715 __THROW _GL_ARG_NONNULL ((1, 2))); 716# endif 717_GL_CXXALIAS_SYS (posix_spawnattr_getsigmask, int, 718 (const posix_spawnattr_t *_Restrict_ __attr, 719 sigset_t *_Restrict_ __sigmask)); 720# endif 721_GL_CXXALIASWARN (posix_spawnattr_getsigmask); 722#elif defined GNULIB_POSIXCHECK 723# undef posix_spawnattr_getsigmask 724# if HAVE_RAW_DECL_POSIX_SPAWNATTR_GETSIGMASK 725_GL_WARN_ON_USE (posix_spawnattr_getsigmask, 726 "posix_spawnattr_getsigmask is unportable - " 727 "use gnulib module posix_spawnattr_getsigmask for portability"); 728# endif 729#endif 730 731#if 1 732/* Set signal mask for the new process in ATTR to SIGMASK. */ 733# if 0 734# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 735# define posix_spawnattr_setsigmask rpl_posix_spawnattr_setsigmask 736# endif 737_GL_FUNCDECL_RPL (posix_spawnattr_setsigmask, int, 738 (posix_spawnattr_t *_Restrict_ __attr, 739 const sigset_t *_Restrict_ __sigmask) 740 __THROW _GL_ARG_NONNULL ((1, 2))); 741_GL_CXXALIAS_RPL (posix_spawnattr_setsigmask, int, 742 (posix_spawnattr_t *_Restrict_ __attr, 743 const sigset_t *_Restrict_ __sigmask)); 744# else 745# if !1 746_GL_FUNCDECL_SYS (posix_spawnattr_setsigmask, int, 747 (posix_spawnattr_t *_Restrict_ __attr, 748 const sigset_t *_Restrict_ __sigmask) 749 __THROW _GL_ARG_NONNULL ((1, 2))); 750# endif 751_GL_CXXALIAS_SYS (posix_spawnattr_setsigmask, int, 752 (posix_spawnattr_t *_Restrict_ __attr, 753 const sigset_t *_Restrict_ __sigmask)); 754# endif 755_GL_CXXALIASWARN (posix_spawnattr_setsigmask); 756#elif defined GNULIB_POSIXCHECK 757# undef posix_spawnattr_setsigmask 758# if HAVE_RAW_DECL_POSIX_SPAWNATTR_SETSIGMASK 759_GL_WARN_ON_USE (posix_spawnattr_setsigmask, 760 "posix_spawnattr_setsigmask is unportable - " 761 "use gnulib module posix_spawnattr_setsigmask for portability"); 762# endif 763#endif 764 765#if 0 766/* Get flag word from the attribute structure. */ 767# if 0 768# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 769# define posix_spawnattr_getflags rpl_posix_spawnattr_getflags 770# endif 771_GL_FUNCDECL_RPL (posix_spawnattr_getflags, int, 772 (const posix_spawnattr_t *_Restrict_ __attr, 773 short int *_Restrict_ __flags) 774 __THROW _GL_ARG_NONNULL ((1, 2))); 775_GL_CXXALIAS_RPL (posix_spawnattr_getflags, int, 776 (const posix_spawnattr_t *_Restrict_ __attr, 777 short int *_Restrict_ __flags)); 778# else 779# if !1 780_GL_FUNCDECL_SYS (posix_spawnattr_getflags, int, 781 (const posix_spawnattr_t *_Restrict_ __attr, 782 short int *_Restrict_ __flags) 783 __THROW _GL_ARG_NONNULL ((1, 2))); 784# endif 785_GL_CXXALIAS_SYS (posix_spawnattr_getflags, int, 786 (const posix_spawnattr_t *_Restrict_ __attr, 787 short int *_Restrict_ __flags)); 788# endif 789_GL_CXXALIASWARN (posix_spawnattr_getflags); 790#elif defined GNULIB_POSIXCHECK 791# undef posix_spawnattr_getflags 792# if HAVE_RAW_DECL_POSIX_SPAWNATTR_GETFLAGS 793_GL_WARN_ON_USE (posix_spawnattr_getflags, 794 "posix_spawnattr_getflags is unportable - " 795 "use gnulib module posix_spawnattr_getflags for portability"); 796# endif 797#endif 798 799#if 1 800/* Store flags in the attribute structure. */ 801# if 0 802# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 803# define posix_spawnattr_setflags rpl_posix_spawnattr_setflags 804# endif 805_GL_FUNCDECL_RPL (posix_spawnattr_setflags, int, 806 (posix_spawnattr_t *__attr, short int __flags) 807 __THROW _GL_ARG_NONNULL ((1))); 808_GL_CXXALIAS_RPL (posix_spawnattr_setflags, int, 809 (posix_spawnattr_t *__attr, short int __flags)); 810# else 811# if !1 812_GL_FUNCDECL_SYS (posix_spawnattr_setflags, int, 813 (posix_spawnattr_t *__attr, short int __flags) 814 __THROW _GL_ARG_NONNULL ((1))); 815# endif 816_GL_CXXALIAS_SYS (posix_spawnattr_setflags, int, 817 (posix_spawnattr_t *__attr, short int __flags)); 818# endif 819_GL_CXXALIASWARN (posix_spawnattr_setflags); 820#elif defined GNULIB_POSIXCHECK 821# undef posix_spawnattr_setflags 822# if HAVE_RAW_DECL_POSIX_SPAWNATTR_SETFLAGS 823_GL_WARN_ON_USE (posix_spawnattr_setflags, 824 "posix_spawnattr_setflags is unportable - " 825 "use gnulib module posix_spawnattr_setflags for portability"); 826# endif 827#endif 828 829#if 0 830/* Get process group ID from the attribute structure. */ 831# if 0 832# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 833# define posix_spawnattr_getpgroup rpl_posix_spawnattr_getpgroup 834# endif 835_GL_FUNCDECL_RPL (posix_spawnattr_getpgroup, int, 836 (const posix_spawnattr_t *_Restrict_ __attr, 837 pid_t *_Restrict_ __pgroup) 838 __THROW _GL_ARG_NONNULL ((1, 2))); 839_GL_CXXALIAS_RPL (posix_spawnattr_getpgroup, int, 840 (const posix_spawnattr_t *_Restrict_ __attr, 841 pid_t *_Restrict_ __pgroup)); 842# else 843# if !1 844_GL_FUNCDECL_SYS (posix_spawnattr_getpgroup, int, 845 (const posix_spawnattr_t *_Restrict_ __attr, 846 pid_t *_Restrict_ __pgroup) 847 __THROW _GL_ARG_NONNULL ((1, 2))); 848# endif 849_GL_CXXALIAS_SYS (posix_spawnattr_getpgroup, int, 850 (const posix_spawnattr_t *_Restrict_ __attr, 851 pid_t *_Restrict_ __pgroup)); 852# endif 853_GL_CXXALIASWARN (posix_spawnattr_getpgroup); 854#elif defined GNULIB_POSIXCHECK 855# undef posix_spawnattr_getpgroup 856# if HAVE_RAW_DECL_POSIX_SPAWNATTR_GETPGROUP 857_GL_WARN_ON_USE (posix_spawnattr_getpgroup, 858 "posix_spawnattr_getpgroup is unportable - " 859 "use gnulib module posix_spawnattr_getpgroup for portability"); 860# endif 861#endif 862 863#if 0 864/* Store process group ID in the attribute structure. */ 865# if 0 866# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 867# define posix_spawnattr_setpgroup rpl_posix_spawnattr_setpgroup 868# endif 869_GL_FUNCDECL_RPL (posix_spawnattr_setpgroup, int, 870 (posix_spawnattr_t *__attr, pid_t __pgroup) 871 __THROW _GL_ARG_NONNULL ((1))); 872_GL_CXXALIAS_RPL (posix_spawnattr_setpgroup, int, 873 (posix_spawnattr_t *__attr, pid_t __pgroup)); 874# else 875# if !1 876_GL_FUNCDECL_SYS (posix_spawnattr_setpgroup, int, 877 (posix_spawnattr_t *__attr, pid_t __pgroup) 878 __THROW _GL_ARG_NONNULL ((1))); 879# endif 880_GL_CXXALIAS_SYS (posix_spawnattr_setpgroup, int, 881 (posix_spawnattr_t *__attr, pid_t __pgroup)); 882# endif 883_GL_CXXALIASWARN (posix_spawnattr_setpgroup); 884#elif defined GNULIB_POSIXCHECK 885# undef posix_spawnattr_setpgroup 886# if HAVE_RAW_DECL_POSIX_SPAWNATTR_SETPGROUP 887_GL_WARN_ON_USE (posix_spawnattr_setpgroup, 888 "posix_spawnattr_setpgroup is unportable - " 889 "use gnulib module posix_spawnattr_setpgroup for portability"); 890# endif 891#endif 892 893#if 0 894/* Get scheduling policy from the attribute structure. */ 895# if 0 896# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 897# define posix_spawnattr_getschedpolicy rpl_posix_spawnattr_getschedpolicy 898# endif 899_GL_FUNCDECL_RPL (posix_spawnattr_getschedpolicy, int, 900 (const posix_spawnattr_t *_Restrict_ __attr, 901 int *_Restrict_ __schedpolicy) 902 __THROW _GL_ARG_NONNULL ((1, 2))); 903_GL_CXXALIAS_RPL (posix_spawnattr_getschedpolicy, int, 904 (const posix_spawnattr_t *_Restrict_ __attr, 905 int *_Restrict_ __schedpolicy)); 906# else 907# if !1 || POSIX_SPAWN_SETSCHEDULER == 0 908_GL_FUNCDECL_SYS (posix_spawnattr_getschedpolicy, int, 909 (const posix_spawnattr_t *_Restrict_ __attr, 910 int *_Restrict_ __schedpolicy) 911 __THROW _GL_ARG_NONNULL ((1, 2))); 912# endif 913_GL_CXXALIAS_SYS (posix_spawnattr_getschedpolicy, int, 914 (const posix_spawnattr_t *_Restrict_ __attr, 915 int *_Restrict_ __schedpolicy)); 916# endif 917_GL_CXXALIASWARN (posix_spawnattr_getschedpolicy); 918#elif defined GNULIB_POSIXCHECK 919# undef posix_spawnattr_getschedpolicy 920# if HAVE_RAW_DECL_POSIX_SPAWNATTR_GETSCHEDPOLICY 921_GL_WARN_ON_USE (posix_spawnattr_getschedpolicy, 922 "posix_spawnattr_getschedpolicy is unportable - " 923 "use gnulib module posix_spawnattr_getschedpolicy for portability"); 924# endif 925#endif 926 927#if 0 928/* Store scheduling policy in the attribute structure. */ 929# if 0 930# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 931# define posix_spawnattr_setschedpolicy rpl_posix_spawnattr_setschedpolicy 932# endif 933_GL_FUNCDECL_RPL (posix_spawnattr_setschedpolicy, int, 934 (posix_spawnattr_t *__attr, int __schedpolicy) 935 __THROW _GL_ARG_NONNULL ((1))); 936_GL_CXXALIAS_RPL (posix_spawnattr_setschedpolicy, int, 937 (posix_spawnattr_t *__attr, int __schedpolicy)); 938# else 939# if !1 || POSIX_SPAWN_SETSCHEDULER == 0 940_GL_FUNCDECL_SYS (posix_spawnattr_setschedpolicy, int, 941 (posix_spawnattr_t *__attr, int __schedpolicy) 942 __THROW _GL_ARG_NONNULL ((1))); 943# endif 944_GL_CXXALIAS_SYS (posix_spawnattr_setschedpolicy, int, 945 (posix_spawnattr_t *__attr, int __schedpolicy)); 946# endif 947_GL_CXXALIASWARN (posix_spawnattr_setschedpolicy); 948#elif defined GNULIB_POSIXCHECK 949# undef posix_spawnattr_setschedpolicy 950# if HAVE_RAW_DECL_POSIX_SPAWNATTR_SETSCHEDPOLICY 951_GL_WARN_ON_USE (posix_spawnattr_setschedpolicy, 952 "posix_spawnattr_setschedpolicy is unportable - " 953 "use gnulib module posix_spawnattr_setschedpolicy for portability"); 954# endif 955#endif 956 957#if 0 958/* Get scheduling parameters from the attribute structure. */ 959# if 0 960# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 961# define posix_spawnattr_getschedparam rpl_posix_spawnattr_getschedparam 962# endif 963_GL_FUNCDECL_RPL (posix_spawnattr_getschedparam, int, 964 (const posix_spawnattr_t *_Restrict_ __attr, 965 struct sched_param *_Restrict_ __schedparam) 966 __THROW _GL_ARG_NONNULL ((1, 2))); 967_GL_CXXALIAS_RPL (posix_spawnattr_getschedparam, int, 968 (const posix_spawnattr_t *_Restrict_ __attr, 969 struct sched_param *_Restrict_ __schedparam)); 970# else 971# if !1 || POSIX_SPAWN_SETSCHEDPARAM == 0 972_GL_FUNCDECL_SYS (posix_spawnattr_getschedparam, int, 973 (const posix_spawnattr_t *_Restrict_ __attr, 974 struct sched_param *_Restrict_ __schedparam) 975 __THROW _GL_ARG_NONNULL ((1, 2))); 976# endif 977_GL_CXXALIAS_SYS (posix_spawnattr_getschedparam, int, 978 (const posix_spawnattr_t *_Restrict_ __attr, 979 struct sched_param *_Restrict_ __schedparam)); 980# endif 981_GL_CXXALIASWARN (posix_spawnattr_getschedparam); 982#elif defined GNULIB_POSIXCHECK 983# undef posix_spawnattr_getschedparam 984# if HAVE_RAW_DECL_POSIX_SPAWNATTR_GETSCHEDPARAM 985_GL_WARN_ON_USE (posix_spawnattr_getschedparam, 986 "posix_spawnattr_getschedparam is unportable - " 987 "use gnulib module posix_spawnattr_getschedparam for portability"); 988# endif 989#endif 990 991#if 0 992/* Store scheduling parameters in the attribute structure. */ 993# if 0 994# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 995# define posix_spawnattr_setschedparam rpl_posix_spawnattr_setschedparam 996# endif 997_GL_FUNCDECL_RPL (posix_spawnattr_setschedparam, int, 998 (posix_spawnattr_t *_Restrict_ __attr, 999 const struct sched_param *_Restrict_ __schedparam) 1000 __THROW _GL_ARG_NONNULL ((1, 2))); 1001_GL_CXXALIAS_RPL (posix_spawnattr_setschedparam, int, 1002 (posix_spawnattr_t *_Restrict_ __attr, 1003 const struct sched_param *_Restrict_ __schedparam)); 1004# else 1005# if !1 || POSIX_SPAWN_SETSCHEDPARAM == 0 1006_GL_FUNCDECL_SYS (posix_spawnattr_setschedparam, int, 1007 (posix_spawnattr_t *_Restrict_ __attr, 1008 const struct sched_param *_Restrict_ __schedparam) 1009 __THROW _GL_ARG_NONNULL ((1, 2))); 1010# endif 1011_GL_CXXALIAS_SYS (posix_spawnattr_setschedparam, int, 1012 (posix_spawnattr_t *_Restrict_ __attr, 1013 const struct sched_param *_Restrict_ __schedparam)); 1014# endif 1015_GL_CXXALIASWARN (posix_spawnattr_setschedparam); 1016#elif defined GNULIB_POSIXCHECK 1017# undef posix_spawnattr_setschedparam 1018# if HAVE_RAW_DECL_POSIX_SPAWNATTR_SETSCHEDPARAM 1019_GL_WARN_ON_USE (posix_spawnattr_setschedparam, 1020 "posix_spawnattr_setschedparam is unportable - " 1021 "use gnulib module posix_spawnattr_setschedparam for portability"); 1022# endif 1023#endif 1024 1025 1026#if 1 1027/* Initialize data structure for file attribute for 'spawn' call. */ 1028# if 0 1029# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1030# define posix_spawn_file_actions_init rpl_posix_spawn_file_actions_init 1031# endif 1032_GL_FUNCDECL_RPL (posix_spawn_file_actions_init, int, 1033 (posix_spawn_file_actions_t *__file_actions) 1034 __THROW _GL_ARG_NONNULL ((1))); 1035_GL_CXXALIAS_RPL (posix_spawn_file_actions_init, int, 1036 (posix_spawn_file_actions_t *__file_actions)); 1037# else 1038# if !1 1039_GL_FUNCDECL_SYS (posix_spawn_file_actions_init, int, 1040 (posix_spawn_file_actions_t *__file_actions) 1041 __THROW _GL_ARG_NONNULL ((1))); 1042# endif 1043_GL_CXXALIAS_SYS (posix_spawn_file_actions_init, int, 1044 (posix_spawn_file_actions_t *__file_actions)); 1045# endif 1046_GL_CXXALIASWARN (posix_spawn_file_actions_init); 1047#elif defined GNULIB_POSIXCHECK 1048# undef posix_spawn_file_actions_init 1049# if HAVE_RAW_DECL_POSIX_SPAWN_FILE_ACTIONS_INIT 1050_GL_WARN_ON_USE (posix_spawn_file_actions_init, 1051 "posix_spawn_file_actions_init is unportable - " 1052 "use gnulib module posix_spawn_file_actions_init for portability"); 1053# endif 1054#endif 1055 1056#if 1 1057/* Free resources associated with FILE-ACTIONS. */ 1058# if 0 1059# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1060# define posix_spawn_file_actions_destroy rpl_posix_spawn_file_actions_destroy 1061# endif 1062_GL_FUNCDECL_RPL (posix_spawn_file_actions_destroy, int, 1063 (posix_spawn_file_actions_t *__file_actions) 1064 __THROW _GL_ARG_NONNULL ((1))); 1065_GL_CXXALIAS_RPL (posix_spawn_file_actions_destroy, int, 1066 (posix_spawn_file_actions_t *__file_actions)); 1067# else 1068# if !1 1069_GL_FUNCDECL_SYS (posix_spawn_file_actions_destroy, int, 1070 (posix_spawn_file_actions_t *__file_actions) 1071 __THROW _GL_ARG_NONNULL ((1))); 1072# endif 1073_GL_CXXALIAS_SYS (posix_spawn_file_actions_destroy, int, 1074 (posix_spawn_file_actions_t *__file_actions)); 1075# endif 1076_GL_CXXALIASWARN (posix_spawn_file_actions_destroy); 1077#elif defined GNULIB_POSIXCHECK 1078# undef posix_spawn_file_actions_destroy 1079# if HAVE_RAW_DECL_POSIX_SPAWN_FILE_ACTIONS_DESTROY 1080_GL_WARN_ON_USE (posix_spawn_file_actions_destroy, 1081 "posix_spawn_file_actions_destroy is unportable - " 1082 "use gnulib module posix_spawn_file_actions_destroy for portability"); 1083# endif 1084#endif 1085 1086#if 1 1087/* Add an action to FILE-ACTIONS which tells the implementation to call 1088 'open' for the given file during the 'spawn' call. */ 1089# if 0 1090# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1091# define posix_spawn_file_actions_addopen rpl_posix_spawn_file_actions_addopen 1092# endif 1093_GL_FUNCDECL_RPL (posix_spawn_file_actions_addopen, int, 1094 (posix_spawn_file_actions_t *_Restrict_ __file_actions, 1095 int __fd, 1096 const char *_Restrict_ __path, int __oflag, mode_t __mode) 1097 __THROW _GL_ARG_NONNULL ((1, 3))); 1098_GL_CXXALIAS_RPL (posix_spawn_file_actions_addopen, int, 1099 (posix_spawn_file_actions_t *_Restrict_ __file_actions, 1100 int __fd, 1101 const char *_Restrict_ __path, int __oflag, mode_t __mode)); 1102# else 1103# if !1 1104_GL_FUNCDECL_SYS (posix_spawn_file_actions_addopen, int, 1105 (posix_spawn_file_actions_t *_Restrict_ __file_actions, 1106 int __fd, 1107 const char *_Restrict_ __path, int __oflag, mode_t __mode) 1108 __THROW _GL_ARG_NONNULL ((1, 3))); 1109# endif 1110_GL_CXXALIAS_SYS (posix_spawn_file_actions_addopen, int, 1111 (posix_spawn_file_actions_t *_Restrict_ __file_actions, 1112 int __fd, 1113 const char *_Restrict_ __path, int __oflag, mode_t __mode)); 1114# endif 1115_GL_CXXALIASWARN (posix_spawn_file_actions_addopen); 1116#elif defined GNULIB_POSIXCHECK 1117# undef posix_spawn_file_actions_addopen 1118# if HAVE_RAW_DECL_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN 1119_GL_WARN_ON_USE (posix_spawn_file_actions_addopen, 1120 "posix_spawn_file_actions_addopen is unportable - " 1121 "use gnulib module posix_spawn_file_actions_addopen for portability"); 1122# endif 1123#endif 1124 1125#if 1 1126/* Add an action to FILE-ACTIONS which tells the implementation to call 1127 'close' for the given file descriptor during the 'spawn' call. */ 1128# if 0 1129# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1130# define posix_spawn_file_actions_addclose rpl_posix_spawn_file_actions_addclose 1131# endif 1132_GL_FUNCDECL_RPL (posix_spawn_file_actions_addclose, int, 1133 (posix_spawn_file_actions_t *__file_actions, int __fd) 1134 __THROW _GL_ARG_NONNULL ((1))); 1135_GL_CXXALIAS_RPL (posix_spawn_file_actions_addclose, int, 1136 (posix_spawn_file_actions_t *__file_actions, int __fd)); 1137# else 1138# if !1 1139_GL_FUNCDECL_SYS (posix_spawn_file_actions_addclose, int, 1140 (posix_spawn_file_actions_t *__file_actions, int __fd) 1141 __THROW _GL_ARG_NONNULL ((1))); 1142# endif 1143_GL_CXXALIAS_SYS (posix_spawn_file_actions_addclose, int, 1144 (posix_spawn_file_actions_t *__file_actions, int __fd)); 1145# endif 1146_GL_CXXALIASWARN (posix_spawn_file_actions_addclose); 1147#elif defined GNULIB_POSIXCHECK 1148# undef posix_spawn_file_actions_addclose 1149# if HAVE_RAW_DECL_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE 1150_GL_WARN_ON_USE (posix_spawn_file_actions_addclose, 1151 "posix_spawn_file_actions_addclose is unportable - " 1152 "use gnulib module posix_spawn_file_actions_addclose for portability"); 1153# endif 1154#endif 1155 1156#if 1 1157/* Add an action to FILE-ACTIONS which tells the implementation to call 1158 'dup2' for the given file descriptors during the 'spawn' call. */ 1159# if 0 1160# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1161# define posix_spawn_file_actions_adddup2 rpl_posix_spawn_file_actions_adddup2 1162# endif 1163_GL_FUNCDECL_RPL (posix_spawn_file_actions_adddup2, int, 1164 (posix_spawn_file_actions_t *__file_actions, 1165 int __fd, int __newfd) 1166 __THROW _GL_ARG_NONNULL ((1))); 1167_GL_CXXALIAS_RPL (posix_spawn_file_actions_adddup2, int, 1168 (posix_spawn_file_actions_t *__file_actions, 1169 int __fd, int __newfd)); 1170# else 1171# if !1 1172_GL_FUNCDECL_SYS (posix_spawn_file_actions_adddup2, int, 1173 (posix_spawn_file_actions_t *__file_actions, 1174 int __fd, int __newfd) 1175 __THROW _GL_ARG_NONNULL ((1))); 1176# endif 1177_GL_CXXALIAS_SYS (posix_spawn_file_actions_adddup2, int, 1178 (posix_spawn_file_actions_t *__file_actions, 1179 int __fd, int __newfd)); 1180# endif 1181_GL_CXXALIASWARN (posix_spawn_file_actions_adddup2); 1182#elif defined GNULIB_POSIXCHECK 1183# undef posix_spawn_file_actions_adddup2 1184# if HAVE_RAW_DECL_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2 1185_GL_WARN_ON_USE (posix_spawn_file_actions_adddup2, 1186 "posix_spawn_file_actions_adddup2 is unportable - " 1187 "use gnulib module posix_spawn_file_actions_adddup2 for portability"); 1188# endif 1189#endif 1190 1191 1192#endif /* _GL_SPAWN_H */ 1193#endif /* _GL_SPAWN_H */ 1194