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) \ 350 extern __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) \ 354 extern __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) \ 370 extern 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) \ 375 extern 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 399 typedef 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 421 typedef 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 468 typedef 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