1/* DO NOT EDIT! GENERATED AUTOMATICALLY! */ 2/* A GNU-like <stdlib.h>. 3 4 Copyright (C) 1995, 2001-2004, 2006-2012 Free Software Foundation, Inc. 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#if __GNUC__ >= 3 20#pragma GCC system_header 21#endif 22 23 24#if defined __need_malloc_and_calloc 25/* Special invocation convention inside glibc header files. */ 26 27#include_next <stdlib.h> 28 29#else 30/* Normal invocation convention. */ 31 32#ifndef _GL_STDLIB_H 33 34/* The include_next requires a split double-inclusion guard. */ 35#include_next <stdlib.h> 36 37#ifndef _GL_STDLIB_H 38#define _GL_STDLIB_H 39 40/* NetBSD 5.0 mis-defines NULL. */ 41#include <stddef.h> 42 43/* MirBSD 10 defines WEXITSTATUS in <sys/wait.h>, not in <stdlib.h>. */ 44#if 0 && !defined WEXITSTATUS 45# include <sys/wait.h> 46#endif 47 48/* Solaris declares getloadavg() in <sys/loadavg.h>. */ 49#if (0 || defined GNULIB_POSIXCHECK) && 0 50# include <sys/loadavg.h> 51#endif 52 53/* Native Windows platforms declare mktemp() in <io.h>. */ 54#if 0 && ((defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__) 55# include <io.h> 56#endif 57 58#if 0 59 60/* OSF/1 5.1 declares 'struct random_data' in <random.h>, which is included 61 from <stdlib.h> if _REENTRANT is defined. Include it whenever we need 62 'struct random_data'. */ 63# if 1 64# include <random.h> 65# endif 66 67# if !1 || 0 || !1 68# include <stdint.h> 69# endif 70 71# if !1 72/* Define 'struct random_data'. 73 But allow multiple gnulib generated <stdlib.h> replacements to coexist. */ 74# if !GNULIB_defined_struct_random_data 75struct random_data 76{ 77 int32_t *fptr; /* Front pointer. */ 78 int32_t *rptr; /* Rear pointer. */ 79 int32_t *state; /* Array of state values. */ 80 int rand_type; /* Type of random number generator. */ 81 int rand_deg; /* Degree of random number generator. */ 82 int rand_sep; /* Distance between front and rear. */ 83 int32_t *end_ptr; /* Pointer behind state table. */ 84}; 85# define GNULIB_defined_struct_random_data 1 86# endif 87# endif 88#endif 89 90#if (0 || 0 || 0 || defined GNULIB_POSIXCHECK) && ! defined __GLIBC__ && !((defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__) 91/* On Mac OS X 10.3, only <unistd.h> declares mkstemp. */ 92/* On Mac OS X 10.5, only <unistd.h> declares mkstemps. */ 93/* On Cygwin 1.7.1, only <unistd.h> declares getsubopt. */ 94/* But avoid namespace pollution on glibc systems and native Windows. */ 95# include <unistd.h> 96#endif 97 98/* The __attribute__ feature is available in gcc versions 2.5 and later. 99 The attribute __pure__ was added in gcc 2.96. */ 100#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96) 101# define _GL_ATTRIBUTE_PURE __attribute__ ((__pure__)) 102#else 103# define _GL_ATTRIBUTE_PURE /* empty */ 104#endif 105 106/* The definition of _Noreturn is copied here. */ 107#if !defined _Noreturn && __STDC_VERSION__ < 201112 108# if (3 <= __GNUC__ || (__GNUC__ == 2 && 8 <= __GNUC_MINOR__) \ 109 || 0x5110 <= __SUNPRO_C) 110# define _Noreturn __attribute__ ((__noreturn__)) 111# elif 1200 <= _MSC_VER 112# define _Noreturn __declspec (noreturn) 113# else 114# define _Noreturn 115# endif 116#endif 117 118/* The definitions of _GL_FUNCDECL_RPL etc. are copied here. */ 119#ifndef _GL_CXXDEFS_H 120#define _GL_CXXDEFS_H 121 122/* The three most frequent use cases of these macros are: 123 124 * For providing a substitute for a function that is missing on some 125 platforms, but is declared and works fine on the platforms on which 126 it exists: 127 128 #if @GNULIB_FOO@ 129 # if !@HAVE_FOO@ 130 _GL_FUNCDECL_SYS (foo, ...); 131 # endif 132 _GL_CXXALIAS_SYS (foo, ...); 133 _GL_CXXALIASWARN (foo); 134 #elif defined GNULIB_POSIXCHECK 135 ... 136 #endif 137 138 * For providing a replacement for a function that exists on all platforms, 139 but is broken/insufficient and needs to be replaced on some platforms: 140 141 #if @GNULIB_FOO@ 142 # if @REPLACE_FOO@ 143 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 144 # undef foo 145 # define foo rpl_foo 146 # endif 147 _GL_FUNCDECL_RPL (foo, ...); 148 _GL_CXXALIAS_RPL (foo, ...); 149 # else 150 _GL_CXXALIAS_SYS (foo, ...); 151 # endif 152 _GL_CXXALIASWARN (foo); 153 #elif defined GNULIB_POSIXCHECK 154 ... 155 #endif 156 157 * For providing a replacement for a function that exists on some platforms 158 but is broken/insufficient and needs to be replaced on some of them and 159 is additionally either missing or undeclared on some other platforms: 160 161 #if @GNULIB_FOO@ 162 # if @REPLACE_FOO@ 163 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 164 # undef foo 165 # define foo rpl_foo 166 # endif 167 _GL_FUNCDECL_RPL (foo, ...); 168 _GL_CXXALIAS_RPL (foo, ...); 169 # else 170 # if !@HAVE_FOO@ or if !@HAVE_DECL_FOO@ 171 _GL_FUNCDECL_SYS (foo, ...); 172 # endif 173 _GL_CXXALIAS_SYS (foo, ...); 174 # endif 175 _GL_CXXALIASWARN (foo); 176 #elif defined GNULIB_POSIXCHECK 177 ... 178 #endif 179*/ 180 181/* _GL_EXTERN_C declaration; 182 performs the declaration with C linkage. */ 183#if defined __cplusplus 184# define _GL_EXTERN_C extern "C" 185#else 186# define _GL_EXTERN_C extern 187#endif 188 189/* _GL_FUNCDECL_RPL (func, rettype, parameters_and_attributes); 190 declares a replacement function, named rpl_func, with the given prototype, 191 consisting of return type, parameters, and attributes. 192 Example: 193 _GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...) 194 _GL_ARG_NONNULL ((1))); 195 */ 196#define _GL_FUNCDECL_RPL(func,rettype,parameters_and_attributes) \ 197 _GL_FUNCDECL_RPL_1 (rpl_##func, rettype, parameters_and_attributes) 198#define _GL_FUNCDECL_RPL_1(rpl_func,rettype,parameters_and_attributes) \ 199 _GL_EXTERN_C rettype rpl_func parameters_and_attributes 200 201/* _GL_FUNCDECL_SYS (func, rettype, parameters_and_attributes); 202 declares the system function, named func, with the given prototype, 203 consisting of return type, parameters, and attributes. 204 Example: 205 _GL_FUNCDECL_SYS (open, int, (const char *filename, int flags, ...) 206 _GL_ARG_NONNULL ((1))); 207 */ 208#define _GL_FUNCDECL_SYS(func,rettype,parameters_and_attributes) \ 209 _GL_EXTERN_C rettype func parameters_and_attributes 210 211/* _GL_CXXALIAS_RPL (func, rettype, parameters); 212 declares a C++ alias called GNULIB_NAMESPACE::func 213 that redirects to rpl_func, if GNULIB_NAMESPACE is defined. 214 Example: 215 _GL_CXXALIAS_RPL (open, int, (const char *filename, int flags, ...)); 216 */ 217#define _GL_CXXALIAS_RPL(func,rettype,parameters) \ 218 _GL_CXXALIAS_RPL_1 (func, rpl_##func, rettype, parameters) 219#if defined __cplusplus && defined GNULIB_NAMESPACE 220# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \ 221 namespace GNULIB_NAMESPACE \ 222 { \ 223 rettype (*const func) parameters = ::rpl_func; \ 224 } \ 225 _GL_EXTERN_C int _gl_cxxalias_dummy 226#else 227# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \ 228 _GL_EXTERN_C int _gl_cxxalias_dummy 229#endif 230 231/* _GL_CXXALIAS_RPL_CAST_1 (func, rpl_func, rettype, parameters); 232 is like _GL_CXXALIAS_RPL_1 (func, rpl_func, rettype, parameters); 233 except that the C function rpl_func may have a slightly different 234 declaration. A cast is used to silence the "invalid conversion" error 235 that would otherwise occur. */ 236#if defined __cplusplus && defined GNULIB_NAMESPACE 237# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \ 238 namespace GNULIB_NAMESPACE \ 239 { \ 240 rettype (*const func) parameters = \ 241 reinterpret_cast<rettype(*)parameters>(::rpl_func); \ 242 } \ 243 _GL_EXTERN_C int _gl_cxxalias_dummy 244#else 245# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \ 246 _GL_EXTERN_C int _gl_cxxalias_dummy 247#endif 248 249/* _GL_CXXALIAS_SYS (func, rettype, parameters); 250 declares a C++ alias called GNULIB_NAMESPACE::func 251 that redirects to the system provided function func, if GNULIB_NAMESPACE 252 is defined. 253 Example: 254 _GL_CXXALIAS_SYS (open, int, (const char *filename, int flags, ...)); 255 */ 256#if defined __cplusplus && defined GNULIB_NAMESPACE 257 /* If we were to write 258 rettype (*const func) parameters = ::func; 259 like above in _GL_CXXALIAS_RPL_1, the compiler could optimize calls 260 better (remove an indirection through a 'static' pointer variable), 261 but then the _GL_CXXALIASWARN macro below would cause a warning not only 262 for uses of ::func but also for uses of GNULIB_NAMESPACE::func. */ 263# define _GL_CXXALIAS_SYS(func,rettype,parameters) \ 264 namespace GNULIB_NAMESPACE \ 265 { \ 266 static rettype (*func) parameters = ::func; \ 267 } \ 268 _GL_EXTERN_C int _gl_cxxalias_dummy 269#else 270# define _GL_CXXALIAS_SYS(func,rettype,parameters) \ 271 _GL_EXTERN_C int _gl_cxxalias_dummy 272#endif 273 274/* _GL_CXXALIAS_SYS_CAST (func, rettype, parameters); 275 is like _GL_CXXALIAS_SYS (func, rettype, parameters); 276 except that the C function func may have a slightly different declaration. 277 A cast is used to silence the "invalid conversion" error that would 278 otherwise occur. */ 279#if defined __cplusplus && defined GNULIB_NAMESPACE 280# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \ 281 namespace GNULIB_NAMESPACE \ 282 { \ 283 static rettype (*func) parameters = \ 284 reinterpret_cast<rettype(*)parameters>(::func); \ 285 } \ 286 _GL_EXTERN_C int _gl_cxxalias_dummy 287#else 288# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \ 289 _GL_EXTERN_C int _gl_cxxalias_dummy 290#endif 291 292/* _GL_CXXALIAS_SYS_CAST2 (func, rettype, parameters, rettype2, parameters2); 293 is like _GL_CXXALIAS_SYS (func, rettype, parameters); 294 except that the C function is picked among a set of overloaded functions, 295 namely the one with rettype2 and parameters2. Two consecutive casts 296 are used to silence the "cannot find a match" and "invalid conversion" 297 errors that would otherwise occur. */ 298#if defined __cplusplus && defined GNULIB_NAMESPACE 299 /* The outer cast must be a reinterpret_cast. 300 The inner cast: When the function is defined as a set of overloaded 301 functions, it works as a static_cast<>, choosing the designated variant. 302 When the function is defined as a single variant, it works as a 303 reinterpret_cast<>. The parenthesized cast syntax works both ways. */ 304# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \ 305 namespace GNULIB_NAMESPACE \ 306 { \ 307 static rettype (*func) parameters = \ 308 reinterpret_cast<rettype(*)parameters>( \ 309 (rettype2(*)parameters2)(::func)); \ 310 } \ 311 _GL_EXTERN_C int _gl_cxxalias_dummy 312#else 313# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \ 314 _GL_EXTERN_C int _gl_cxxalias_dummy 315#endif 316 317/* _GL_CXXALIASWARN (func); 318 causes a warning to be emitted when ::func is used but not when 319 GNULIB_NAMESPACE::func is used. func must be defined without overloaded 320 variants. */ 321#if defined __cplusplus && defined GNULIB_NAMESPACE 322# define _GL_CXXALIASWARN(func) \ 323 _GL_CXXALIASWARN_1 (func, GNULIB_NAMESPACE) 324# define _GL_CXXALIASWARN_1(func,namespace) \ 325 _GL_CXXALIASWARN_2 (func, namespace) 326/* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>, 327 we enable the warning only when not optimizing. */ 328# if !__OPTIMIZE__ 329# define _GL_CXXALIASWARN_2(func,namespace) \ 330 _GL_WARN_ON_USE (func, \ 331 "The symbol ::" #func " refers to the system function. " \ 332 "Use " #namespace "::" #func " instead.") 333# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 334# define _GL_CXXALIASWARN_2(func,namespace) \ 335 extern __typeof__ (func) func 336# else 337# define _GL_CXXALIASWARN_2(func,namespace) \ 338 _GL_EXTERN_C int _gl_cxxalias_dummy 339# endif 340#else 341# define _GL_CXXALIASWARN(func) \ 342 _GL_EXTERN_C int _gl_cxxalias_dummy 343#endif 344 345/* _GL_CXXALIASWARN1 (func, rettype, parameters_and_attributes); 346 causes a warning to be emitted when the given overloaded variant of ::func 347 is used but not when GNULIB_NAMESPACE::func is used. */ 348#if defined __cplusplus && defined GNULIB_NAMESPACE 349# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \ 350 _GL_CXXALIASWARN1_1 (func, rettype, parameters_and_attributes, \ 351 GNULIB_NAMESPACE) 352# define _GL_CXXALIASWARN1_1(func,rettype,parameters_and_attributes,namespace) \ 353 _GL_CXXALIASWARN1_2 (func, rettype, parameters_and_attributes, namespace) 354/* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>, 355 we enable the warning only when not optimizing. */ 356# if !__OPTIMIZE__ 357# define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \ 358 _GL_WARN_ON_USE_CXX (func, rettype, parameters_and_attributes, \ 359 "The symbol ::" #func " refers to the system function. " \ 360 "Use " #namespace "::" #func " instead.") 361# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 362# define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \ 363 extern __typeof__ (func) func 364# else 365# define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \ 366 _GL_EXTERN_C int _gl_cxxalias_dummy 367# endif 368#else 369# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \ 370 _GL_EXTERN_C int _gl_cxxalias_dummy 371#endif 372 373#endif /* _GL_CXXDEFS_H */ 374 375/* The definition of _GL_ARG_NONNULL is copied here. */ 376/* _GL_ARG_NONNULL((n,...,m)) tells the compiler and static analyzer tools 377 that the values passed as arguments n, ..., m must be non-NULL pointers. 378 n = 1 stands for the first argument, n = 2 for the second argument etc. */ 379#ifndef _GL_ARG_NONNULL 380# if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || __GNUC__ > 3 381# define _GL_ARG_NONNULL(params) __attribute__ ((__nonnull__ params)) 382# else 383# define _GL_ARG_NONNULL(params) 384# endif 385#endif 386 387/* The definition of _GL_WARN_ON_USE is copied here. */ 388#ifndef _GL_WARN_ON_USE 389 390# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__) 391/* A compiler attribute is available in gcc versions 4.3.0 and later. */ 392# define _GL_WARN_ON_USE(function, message) \ 393extern __typeof__ (function) function __attribute__ ((__warning__ (message))) 394# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 395/* Verify the existence of the function. */ 396# define _GL_WARN_ON_USE(function, message) \ 397extern __typeof__ (function) function 398# else /* Unsupported. */ 399# define _GL_WARN_ON_USE(function, message) \ 400_GL_WARN_EXTERN_C int _gl_warn_on_use 401# endif 402#endif 403 404/* _GL_WARN_ON_USE_CXX (function, rettype, parameters_and_attributes, "string") 405 is like _GL_WARN_ON_USE (function, "string"), except that the function is 406 declared with the given prototype, consisting of return type, parameters, 407 and attributes. 408 This variant is useful for overloaded functions in C++. _GL_WARN_ON_USE does 409 not work in this case. */ 410#ifndef _GL_WARN_ON_USE_CXX 411# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__) 412# define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \ 413extern rettype function parameters_and_attributes \ 414 __attribute__ ((__warning__ (msg))) 415# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 416/* Verify the existence of the function. */ 417# define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \ 418extern rettype function parameters_and_attributes 419# else /* Unsupported. */ 420# define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \ 421_GL_WARN_EXTERN_C int _gl_warn_on_use 422# endif 423#endif 424 425/* _GL_WARN_EXTERN_C declaration; 426 performs the declaration with C linkage. */ 427#ifndef _GL_WARN_EXTERN_C 428# if defined __cplusplus 429# define _GL_WARN_EXTERN_C extern "C" 430# else 431# define _GL_WARN_EXTERN_C extern 432# endif 433#endif 434 435 436/* Some systems do not define EXIT_*, despite otherwise supporting C89. */ 437#ifndef EXIT_SUCCESS 438# define EXIT_SUCCESS 0 439#endif 440/* Tandem/NSK and other platforms that define EXIT_FAILURE as -1 interfere 441 with proper operation of xargs. */ 442#ifndef EXIT_FAILURE 443# define EXIT_FAILURE 1 444#elif EXIT_FAILURE != 1 445# undef EXIT_FAILURE 446# define EXIT_FAILURE 1 447#endif 448 449 450#if 0 451/* Terminate the current process with the given return code, without running 452 the 'atexit' handlers. */ 453# if !1 454_GL_FUNCDECL_SYS (_Exit, _Noreturn void, (int status)); 455# endif 456_GL_CXXALIAS_SYS (_Exit, void, (int status)); 457_GL_CXXALIASWARN (_Exit); 458#elif defined GNULIB_POSIXCHECK 459# undef _Exit 460# if HAVE_RAW_DECL__EXIT 461_GL_WARN_ON_USE (_Exit, "_Exit is unportable - " 462 "use gnulib module _Exit for portability"); 463# endif 464#endif 465 466 467#if 0 468/* Parse a signed decimal integer. 469 Returns the value of the integer. Errors are not detected. */ 470# if !1 471_GL_FUNCDECL_SYS (atoll, long long, (const char *string) 472 _GL_ATTRIBUTE_PURE 473 _GL_ARG_NONNULL ((1))); 474# endif 475_GL_CXXALIAS_SYS (atoll, long long, (const char *string)); 476_GL_CXXALIASWARN (atoll); 477#elif defined GNULIB_POSIXCHECK 478# undef atoll 479# if HAVE_RAW_DECL_ATOLL 480_GL_WARN_ON_USE (atoll, "atoll is unportable - " 481 "use gnulib module atoll for portability"); 482# endif 483#endif 484 485#if 1 486# if 0 487# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 488# undef calloc 489# define calloc rpl_calloc 490# endif 491_GL_FUNCDECL_RPL (calloc, void *, (size_t nmemb, size_t size)); 492_GL_CXXALIAS_RPL (calloc, void *, (size_t nmemb, size_t size)); 493# else 494_GL_CXXALIAS_SYS (calloc, void *, (size_t nmemb, size_t size)); 495# endif 496_GL_CXXALIASWARN (calloc); 497#elif defined GNULIB_POSIXCHECK 498# undef calloc 499/* Assume calloc is always declared. */ 500_GL_WARN_ON_USE (calloc, "calloc is not POSIX compliant everywhere - " 501 "use gnulib module calloc-posix for portability"); 502#endif 503 504#if 0 505# if 0 506# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 507# define canonicalize_file_name rpl_canonicalize_file_name 508# endif 509_GL_FUNCDECL_RPL (canonicalize_file_name, char *, (const char *name) 510 _GL_ARG_NONNULL ((1))); 511_GL_CXXALIAS_RPL (canonicalize_file_name, char *, (const char *name)); 512# else 513# if !1 514_GL_FUNCDECL_SYS (canonicalize_file_name, char *, (const char *name) 515 _GL_ARG_NONNULL ((1))); 516# endif 517_GL_CXXALIAS_SYS (canonicalize_file_name, char *, (const char *name)); 518# endif 519_GL_CXXALIASWARN (canonicalize_file_name); 520#elif defined GNULIB_POSIXCHECK 521# undef canonicalize_file_name 522# if HAVE_RAW_DECL_CANONICALIZE_FILE_NAME 523_GL_WARN_ON_USE (canonicalize_file_name, 524 "canonicalize_file_name is unportable - " 525 "use gnulib module canonicalize-lgpl for portability"); 526# endif 527#endif 528 529#if 0 530/* Store max(NELEM,3) load average numbers in LOADAVG[]. 531 The three numbers are the load average of the last 1 minute, the last 5 532 minutes, and the last 15 minutes, respectively. 533 LOADAVG is an array of NELEM numbers. */ 534# if !1 535_GL_FUNCDECL_SYS (getloadavg, int, (double loadavg[], int nelem) 536 _GL_ARG_NONNULL ((1))); 537# endif 538_GL_CXXALIAS_SYS (getloadavg, int, (double loadavg[], int nelem)); 539_GL_CXXALIASWARN (getloadavg); 540#elif defined GNULIB_POSIXCHECK 541# undef getloadavg 542# if HAVE_RAW_DECL_GETLOADAVG 543_GL_WARN_ON_USE (getloadavg, "getloadavg is not portable - " 544 "use gnulib module getloadavg for portability"); 545# endif 546#endif 547 548#if 0 549/* Assuming *OPTIONP is a comma separated list of elements of the form 550 "token" or "token=value", getsubopt parses the first of these elements. 551 If the first element refers to a "token" that is member of the given 552 NULL-terminated array of tokens: 553 - It replaces the comma with a NUL byte, updates *OPTIONP to point past 554 the first option and the comma, sets *VALUEP to the value of the 555 element (or NULL if it doesn't contain an "=" sign), 556 - It returns the index of the "token" in the given array of tokens. 557 Otherwise it returns -1, and *OPTIONP and *VALUEP are undefined. 558 For more details see the POSIX:2001 specification. 559 http://www.opengroup.org/susv3xsh/getsubopt.html */ 560# if !1 561_GL_FUNCDECL_SYS (getsubopt, int, 562 (char **optionp, char *const *tokens, char **valuep) 563 _GL_ARG_NONNULL ((1, 2, 3))); 564# endif 565_GL_CXXALIAS_SYS (getsubopt, int, 566 (char **optionp, char *const *tokens, char **valuep)); 567_GL_CXXALIASWARN (getsubopt); 568#elif defined GNULIB_POSIXCHECK 569# undef getsubopt 570# if HAVE_RAW_DECL_GETSUBOPT 571_GL_WARN_ON_USE (getsubopt, "getsubopt is unportable - " 572 "use gnulib module getsubopt for portability"); 573# endif 574#endif 575 576#if 0 577/* Change the ownership and access permission of the slave side of the 578 pseudo-terminal whose master side is specified by FD. */ 579# if !1 580_GL_FUNCDECL_SYS (grantpt, int, (int fd)); 581# endif 582_GL_CXXALIAS_SYS (grantpt, int, (int fd)); 583_GL_CXXALIASWARN (grantpt); 584#elif defined GNULIB_POSIXCHECK 585# undef grantpt 586# if HAVE_RAW_DECL_GRANTPT 587_GL_WARN_ON_USE (grantpt, "grantpt is not portable - " 588 "use gnulib module grantpt for portability"); 589# endif 590#endif 591 592/* If _GL_USE_STDLIB_ALLOC is nonzero, the including module does not 593 rely on GNU or POSIX semantics for malloc and realloc (for example, 594 by never specifying a zero size), so it does not need malloc or 595 realloc to be redefined. */ 596#if 1 597# if 0 598# if !((defined __cplusplus && defined GNULIB_NAMESPACE) \ 599 || _GL_USE_STDLIB_ALLOC) 600# undef malloc 601# define malloc rpl_malloc 602# endif 603_GL_FUNCDECL_RPL (malloc, void *, (size_t size)); 604_GL_CXXALIAS_RPL (malloc, void *, (size_t size)); 605# else 606_GL_CXXALIAS_SYS (malloc, void *, (size_t size)); 607# endif 608_GL_CXXALIASWARN (malloc); 609#elif defined GNULIB_POSIXCHECK && !_GL_USE_STDLIB_ALLOC 610# undef malloc 611/* Assume malloc is always declared. */ 612_GL_WARN_ON_USE (malloc, "malloc is not POSIX compliant everywhere - " 613 "use gnulib module malloc-posix for portability"); 614#endif 615 616/* Convert a multibyte character to a wide character. */ 617#if 0 618# if 0 619# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 620# undef mbtowc 621# define mbtowc rpl_mbtowc 622# endif 623_GL_FUNCDECL_RPL (mbtowc, int, (wchar_t *pwc, const char *s, size_t n)); 624_GL_CXXALIAS_RPL (mbtowc, int, (wchar_t *pwc, const char *s, size_t n)); 625# else 626_GL_CXXALIAS_SYS (mbtowc, int, (wchar_t *pwc, const char *s, size_t n)); 627# endif 628_GL_CXXALIASWARN (mbtowc); 629#endif 630 631#if 0 632/* Create a unique temporary directory from TEMPLATE. 633 The last six characters of TEMPLATE must be "XXXXXX"; 634 they are replaced with a string that makes the directory name unique. 635 Returns TEMPLATE, or a null pointer if it cannot get a unique name. 636 The directory is created mode 700. */ 637# if !1 638_GL_FUNCDECL_SYS (mkdtemp, char *, (char * /*template*/) _GL_ARG_NONNULL ((1))); 639# endif 640_GL_CXXALIAS_SYS (mkdtemp, char *, (char * /*template*/)); 641_GL_CXXALIASWARN (mkdtemp); 642#elif defined GNULIB_POSIXCHECK 643# undef mkdtemp 644# if HAVE_RAW_DECL_MKDTEMP 645_GL_WARN_ON_USE (mkdtemp, "mkdtemp is unportable - " 646 "use gnulib module mkdtemp for portability"); 647# endif 648#endif 649 650#if 0 651/* Create a unique temporary file from TEMPLATE. 652 The last six characters of TEMPLATE must be "XXXXXX"; 653 they are replaced with a string that makes the file name unique. 654 The flags are a bitmask, possibly including O_CLOEXEC (defined in <fcntl.h>) 655 and O_TEXT, O_BINARY (defined in "binary-io.h"). 656 The file is then created, with the specified flags, ensuring it didn't exist 657 before. 658 The file is created read-write (mask at least 0600 & ~umask), but it may be 659 world-readable and world-writable (mask 0666 & ~umask), depending on the 660 implementation. 661 Returns the open file descriptor if successful, otherwise -1 and errno 662 set. */ 663# if !1 664_GL_FUNCDECL_SYS (mkostemp, int, (char * /*template*/, int /*flags*/) 665 _GL_ARG_NONNULL ((1))); 666# endif 667_GL_CXXALIAS_SYS (mkostemp, int, (char * /*template*/, int /*flags*/)); 668_GL_CXXALIASWARN (mkostemp); 669#elif defined GNULIB_POSIXCHECK 670# undef mkostemp 671# if HAVE_RAW_DECL_MKOSTEMP 672_GL_WARN_ON_USE (mkostemp, "mkostemp is unportable - " 673 "use gnulib module mkostemp for portability"); 674# endif 675#endif 676 677#if 0 678/* Create a unique temporary file from TEMPLATE. 679 The last six characters of TEMPLATE before a suffix of length 680 SUFFIXLEN must be "XXXXXX"; 681 they are replaced with a string that makes the file name unique. 682 The flags are a bitmask, possibly including O_CLOEXEC (defined in <fcntl.h>) 683 and O_TEXT, O_BINARY (defined in "binary-io.h"). 684 The file is then created, with the specified flags, ensuring it didn't exist 685 before. 686 The file is created read-write (mask at least 0600 & ~umask), but it may be 687 world-readable and world-writable (mask 0666 & ~umask), depending on the 688 implementation. 689 Returns the open file descriptor if successful, otherwise -1 and errno 690 set. */ 691# if !1 692_GL_FUNCDECL_SYS (mkostemps, int, 693 (char * /*template*/, int /*suffixlen*/, int /*flags*/) 694 _GL_ARG_NONNULL ((1))); 695# endif 696_GL_CXXALIAS_SYS (mkostemps, int, 697 (char * /*template*/, int /*suffixlen*/, int /*flags*/)); 698_GL_CXXALIASWARN (mkostemps); 699#elif defined GNULIB_POSIXCHECK 700# undef mkostemps 701# if HAVE_RAW_DECL_MKOSTEMPS 702_GL_WARN_ON_USE (mkostemps, "mkostemps is unportable - " 703 "use gnulib module mkostemps for portability"); 704# endif 705#endif 706 707#if 0 708/* Create a unique temporary file from TEMPLATE. 709 The last six characters of TEMPLATE must be "XXXXXX"; 710 they are replaced with a string that makes the file name unique. 711 The file is then created, ensuring it didn't exist before. 712 The file is created read-write (mask at least 0600 & ~umask), but it may be 713 world-readable and world-writable (mask 0666 & ~umask), depending on the 714 implementation. 715 Returns the open file descriptor if successful, otherwise -1 and errno 716 set. */ 717# if 0 718# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 719# define mkstemp rpl_mkstemp 720# endif 721_GL_FUNCDECL_RPL (mkstemp, int, (char * /*template*/) _GL_ARG_NONNULL ((1))); 722_GL_CXXALIAS_RPL (mkstemp, int, (char * /*template*/)); 723# else 724# if ! 1 725_GL_FUNCDECL_SYS (mkstemp, int, (char * /*template*/) _GL_ARG_NONNULL ((1))); 726# endif 727_GL_CXXALIAS_SYS (mkstemp, int, (char * /*template*/)); 728# endif 729_GL_CXXALIASWARN (mkstemp); 730#elif defined GNULIB_POSIXCHECK 731# undef mkstemp 732# if HAVE_RAW_DECL_MKSTEMP 733_GL_WARN_ON_USE (mkstemp, "mkstemp is unportable - " 734 "use gnulib module mkstemp for portability"); 735# endif 736#endif 737 738#if 0 739/* Create a unique temporary file from TEMPLATE. 740 The last six characters of TEMPLATE prior to a suffix of length 741 SUFFIXLEN must be "XXXXXX"; 742 they are replaced with a string that makes the file name unique. 743 The file is then created, ensuring it didn't exist before. 744 The file is created read-write (mask at least 0600 & ~umask), but it may be 745 world-readable and world-writable (mask 0666 & ~umask), depending on the 746 implementation. 747 Returns the open file descriptor if successful, otherwise -1 and errno 748 set. */ 749# if !1 750_GL_FUNCDECL_SYS (mkstemps, int, (char * /*template*/, int /*suffixlen*/) 751 _GL_ARG_NONNULL ((1))); 752# endif 753_GL_CXXALIAS_SYS (mkstemps, int, (char * /*template*/, int /*suffixlen*/)); 754_GL_CXXALIASWARN (mkstemps); 755#elif defined GNULIB_POSIXCHECK 756# undef mkstemps 757# if HAVE_RAW_DECL_MKSTEMPS 758_GL_WARN_ON_USE (mkstemps, "mkstemps is unportable - " 759 "use gnulib module mkstemps for portability"); 760# endif 761#endif 762 763#if 0 764/* Return an FD open to the master side of a pseudo-terminal. Flags should 765 include O_RDWR, and may also include O_NOCTTY. */ 766# if !1 767_GL_FUNCDECL_SYS (posix_openpt, int, (int flags)); 768# endif 769_GL_CXXALIAS_SYS (posix_openpt, int, (int flags)); 770_GL_CXXALIASWARN (posix_openpt); 771#elif defined GNULIB_POSIXCHECK 772# undef posix_openpt 773# if HAVE_RAW_DECL_POSIX_OPENPT 774_GL_WARN_ON_USE (posix_openpt, "posix_openpt is not portable - " 775 "use gnulib module posix_openpt for portability"); 776# endif 777#endif 778 779#if 0 780/* Return the pathname of the pseudo-terminal slave associated with 781 the master FD is open on, or NULL on errors. */ 782# if 0 783# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 784# undef ptsname 785# define ptsname rpl_ptsname 786# endif 787_GL_FUNCDECL_RPL (ptsname, char *, (int fd)); 788_GL_CXXALIAS_RPL (ptsname, char *, (int fd)); 789# else 790# if !1 791_GL_FUNCDECL_SYS (ptsname, char *, (int fd)); 792# endif 793_GL_CXXALIAS_SYS (ptsname, char *, (int fd)); 794# endif 795_GL_CXXALIASWARN (ptsname); 796#elif defined GNULIB_POSIXCHECK 797# undef ptsname 798# if HAVE_RAW_DECL_PTSNAME 799_GL_WARN_ON_USE (ptsname, "ptsname is not portable - " 800 "use gnulib module ptsname for portability"); 801# endif 802#endif 803 804#if 0 805/* Set the pathname of the pseudo-terminal slave associated with 806 the master FD is open on and return 0, or set errno and return 807 non-zero on errors. */ 808# if 0 809# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 810# undef ptsname_r 811# define ptsname_r rpl_ptsname_r 812# endif 813_GL_FUNCDECL_RPL (ptsname_r, int, (int fd, char *buf, size_t len)); 814_GL_CXXALIAS_RPL (ptsname_r, int, (int fd, char *buf, size_t len)); 815# else 816# if !1 817_GL_FUNCDECL_SYS (ptsname_r, int, (int fd, char *buf, size_t len)); 818# endif 819_GL_CXXALIAS_SYS (ptsname_r, int, (int fd, char *buf, size_t len)); 820# endif 821_GL_CXXALIASWARN (ptsname_r); 822#elif defined GNULIB_POSIXCHECK 823# undef ptsname_r 824# if HAVE_RAW_DECL_PTSNAME_R 825_GL_WARN_ON_USE (ptsname_r, "ptsname_r is not portable - " 826 "use gnulib module ptsname_r for portability"); 827# endif 828#endif 829 830#if 0 831# if 0 832# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 833# undef putenv 834# define putenv rpl_putenv 835# endif 836_GL_FUNCDECL_RPL (putenv, int, (char *string) _GL_ARG_NONNULL ((1))); 837_GL_CXXALIAS_RPL (putenv, int, (char *string)); 838# else 839_GL_CXXALIAS_SYS (putenv, int, (char *string)); 840# endif 841_GL_CXXALIASWARN (putenv); 842#endif 843 844 845#if 0 846# if !1 847# ifndef RAND_MAX 848# define RAND_MAX 2147483647 849# endif 850# endif 851#endif 852 853 854#if 0 855# if !1 856_GL_FUNCDECL_SYS (random, long, (void)); 857# endif 858_GL_CXXALIAS_SYS (random, long, (void)); 859_GL_CXXALIASWARN (random); 860#elif defined GNULIB_POSIXCHECK 861# undef random 862# if HAVE_RAW_DECL_RANDOM 863_GL_WARN_ON_USE (random, "random is unportable - " 864 "use gnulib module random for portability"); 865# endif 866#endif 867 868#if 0 869# if !1 870_GL_FUNCDECL_SYS (srandom, void, (unsigned int seed)); 871# endif 872_GL_CXXALIAS_SYS (srandom, void, (unsigned int seed)); 873_GL_CXXALIASWARN (srandom); 874#elif defined GNULIB_POSIXCHECK 875# undef srandom 876# if HAVE_RAW_DECL_SRANDOM 877_GL_WARN_ON_USE (srandom, "srandom is unportable - " 878 "use gnulib module random for portability"); 879# endif 880#endif 881 882#if 0 883# if !1 884_GL_FUNCDECL_SYS (initstate, char *, 885 (unsigned int seed, char *buf, size_t buf_size) 886 _GL_ARG_NONNULL ((2))); 887# endif 888_GL_CXXALIAS_SYS (initstate, char *, 889 (unsigned int seed, char *buf, size_t buf_size)); 890_GL_CXXALIASWARN (initstate); 891#elif defined GNULIB_POSIXCHECK 892# undef initstate 893# if HAVE_RAW_DECL_INITSTATE_R 894_GL_WARN_ON_USE (initstate, "initstate is unportable - " 895 "use gnulib module random for portability"); 896# endif 897#endif 898 899#if 0 900# if !1 901_GL_FUNCDECL_SYS (setstate, char *, (char *arg_state) _GL_ARG_NONNULL ((1))); 902# endif 903_GL_CXXALIAS_SYS (setstate, char *, (char *arg_state)); 904_GL_CXXALIASWARN (setstate); 905#elif defined GNULIB_POSIXCHECK 906# undef setstate 907# if HAVE_RAW_DECL_SETSTATE_R 908_GL_WARN_ON_USE (setstate, "setstate is unportable - " 909 "use gnulib module random for portability"); 910# endif 911#endif 912 913 914#if 0 915# if 0 916# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 917# undef random_r 918# define random_r rpl_random_r 919# endif 920_GL_FUNCDECL_RPL (random_r, int, (struct random_data *buf, int32_t *result) 921 _GL_ARG_NONNULL ((1, 2))); 922_GL_CXXALIAS_RPL (random_r, int, (struct random_data *buf, int32_t *result)); 923# else 924# if !1 925_GL_FUNCDECL_SYS (random_r, int, (struct random_data *buf, int32_t *result) 926 _GL_ARG_NONNULL ((1, 2))); 927# endif 928_GL_CXXALIAS_SYS (random_r, int, (struct random_data *buf, int32_t *result)); 929# endif 930_GL_CXXALIASWARN (random_r); 931#elif defined GNULIB_POSIXCHECK 932# undef random_r 933# if HAVE_RAW_DECL_RANDOM_R 934_GL_WARN_ON_USE (random_r, "random_r is unportable - " 935 "use gnulib module random_r for portability"); 936# endif 937#endif 938 939#if 0 940# if 0 941# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 942# undef srandom_r 943# define srandom_r rpl_srandom_r 944# endif 945_GL_FUNCDECL_RPL (srandom_r, int, 946 (unsigned int seed, struct random_data *rand_state) 947 _GL_ARG_NONNULL ((2))); 948_GL_CXXALIAS_RPL (srandom_r, int, 949 (unsigned int seed, struct random_data *rand_state)); 950# else 951# if !1 952_GL_FUNCDECL_SYS (srandom_r, int, 953 (unsigned int seed, struct random_data *rand_state) 954 _GL_ARG_NONNULL ((2))); 955# endif 956_GL_CXXALIAS_SYS (srandom_r, int, 957 (unsigned int seed, struct random_data *rand_state)); 958# endif 959_GL_CXXALIASWARN (srandom_r); 960#elif defined GNULIB_POSIXCHECK 961# undef srandom_r 962# if HAVE_RAW_DECL_SRANDOM_R 963_GL_WARN_ON_USE (srandom_r, "srandom_r is unportable - " 964 "use gnulib module random_r for portability"); 965# endif 966#endif 967 968#if 0 969# if 0 970# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 971# undef initstate_r 972# define initstate_r rpl_initstate_r 973# endif 974_GL_FUNCDECL_RPL (initstate_r, int, 975 (unsigned int seed, char *buf, size_t buf_size, 976 struct random_data *rand_state) 977 _GL_ARG_NONNULL ((2, 4))); 978_GL_CXXALIAS_RPL (initstate_r, int, 979 (unsigned int seed, char *buf, size_t buf_size, 980 struct random_data *rand_state)); 981# else 982# if !1 983_GL_FUNCDECL_SYS (initstate_r, int, 984 (unsigned int seed, char *buf, size_t buf_size, 985 struct random_data *rand_state) 986 _GL_ARG_NONNULL ((2, 4))); 987# endif 988_GL_CXXALIAS_SYS (initstate_r, int, 989 (unsigned int seed, char *buf, size_t buf_size, 990 struct random_data *rand_state)); 991# endif 992_GL_CXXALIASWARN (initstate_r); 993#elif defined GNULIB_POSIXCHECK 994# undef initstate_r 995# if HAVE_RAW_DECL_INITSTATE_R 996_GL_WARN_ON_USE (initstate_r, "initstate_r is unportable - " 997 "use gnulib module random_r for portability"); 998# endif 999#endif 1000 1001#if 0 1002# if 0 1003# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1004# undef setstate_r 1005# define setstate_r rpl_setstate_r 1006# endif 1007_GL_FUNCDECL_RPL (setstate_r, int, 1008 (char *arg_state, struct random_data *rand_state) 1009 _GL_ARG_NONNULL ((1, 2))); 1010_GL_CXXALIAS_RPL (setstate_r, int, 1011 (char *arg_state, struct random_data *rand_state)); 1012# else 1013# if !1 1014_GL_FUNCDECL_SYS (setstate_r, int, 1015 (char *arg_state, struct random_data *rand_state) 1016 _GL_ARG_NONNULL ((1, 2))); 1017# endif 1018_GL_CXXALIAS_SYS (setstate_r, int, 1019 (char *arg_state, struct random_data *rand_state)); 1020# endif 1021_GL_CXXALIASWARN (setstate_r); 1022#elif defined GNULIB_POSIXCHECK 1023# undef setstate_r 1024# if HAVE_RAW_DECL_SETSTATE_R 1025_GL_WARN_ON_USE (setstate_r, "setstate_r is unportable - " 1026 "use gnulib module random_r for portability"); 1027# endif 1028#endif 1029 1030 1031#if 1 1032# if 0 1033# if !((defined __cplusplus && defined GNULIB_NAMESPACE) \ 1034 || _GL_USE_STDLIB_ALLOC) 1035# undef realloc 1036# define realloc rpl_realloc 1037# endif 1038_GL_FUNCDECL_RPL (realloc, void *, (void *ptr, size_t size)); 1039_GL_CXXALIAS_RPL (realloc, void *, (void *ptr, size_t size)); 1040# else 1041_GL_CXXALIAS_SYS (realloc, void *, (void *ptr, size_t size)); 1042# endif 1043_GL_CXXALIASWARN (realloc); 1044#elif defined GNULIB_POSIXCHECK && !_GL_USE_STDLIB_ALLOC 1045# undef realloc 1046/* Assume realloc is always declared. */ 1047_GL_WARN_ON_USE (realloc, "realloc is not POSIX compliant everywhere - " 1048 "use gnulib module realloc-posix for portability"); 1049#endif 1050 1051#if 0 1052# if 0 1053# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1054# define realpath rpl_realpath 1055# endif 1056_GL_FUNCDECL_RPL (realpath, char *, (const char *name, char *resolved) 1057 _GL_ARG_NONNULL ((1))); 1058_GL_CXXALIAS_RPL (realpath, char *, (const char *name, char *resolved)); 1059# else 1060# if !1 1061_GL_FUNCDECL_SYS (realpath, char *, (const char *name, char *resolved) 1062 _GL_ARG_NONNULL ((1))); 1063# endif 1064_GL_CXXALIAS_SYS (realpath, char *, (const char *name, char *resolved)); 1065# endif 1066_GL_CXXALIASWARN (realpath); 1067#elif defined GNULIB_POSIXCHECK 1068# undef realpath 1069# if HAVE_RAW_DECL_REALPATH 1070_GL_WARN_ON_USE (realpath, "realpath is unportable - use gnulib module " 1071 "canonicalize or canonicalize-lgpl for portability"); 1072# endif 1073#endif 1074 1075#if 0 1076/* Test a user response to a question. 1077 Return 1 if it is affirmative, 0 if it is negative, or -1 if not clear. */ 1078# if !1 1079_GL_FUNCDECL_SYS (rpmatch, int, (const char *response) _GL_ARG_NONNULL ((1))); 1080# endif 1081_GL_CXXALIAS_SYS (rpmatch, int, (const char *response)); 1082_GL_CXXALIASWARN (rpmatch); 1083#elif defined GNULIB_POSIXCHECK 1084# undef rpmatch 1085# if HAVE_RAW_DECL_RPMATCH 1086_GL_WARN_ON_USE (rpmatch, "rpmatch is unportable - " 1087 "use gnulib module rpmatch for portability"); 1088# endif 1089#endif 1090 1091#if 0 1092/* Set NAME to VALUE in the environment. 1093 If REPLACE is nonzero, overwrite an existing value. */ 1094# if 0 1095# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1096# undef setenv 1097# define setenv rpl_setenv 1098# endif 1099_GL_FUNCDECL_RPL (setenv, int, 1100 (const char *name, const char *value, int replace) 1101 _GL_ARG_NONNULL ((1))); 1102_GL_CXXALIAS_RPL (setenv, int, 1103 (const char *name, const char *value, int replace)); 1104# else 1105# if !1 1106_GL_FUNCDECL_SYS (setenv, int, 1107 (const char *name, const char *value, int replace) 1108 _GL_ARG_NONNULL ((1))); 1109# endif 1110_GL_CXXALIAS_SYS (setenv, int, 1111 (const char *name, const char *value, int replace)); 1112# endif 1113# if !(0 && !1) 1114_GL_CXXALIASWARN (setenv); 1115# endif 1116#elif defined GNULIB_POSIXCHECK 1117# undef setenv 1118# if HAVE_RAW_DECL_SETENV 1119_GL_WARN_ON_USE (setenv, "setenv is unportable - " 1120 "use gnulib module setenv for portability"); 1121# endif 1122#endif 1123 1124#if 0 1125 /* Parse a double from STRING, updating ENDP if appropriate. */ 1126# if 0 1127# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1128# define strtod rpl_strtod 1129# endif 1130_GL_FUNCDECL_RPL (strtod, double, (const char *str, char **endp) 1131 _GL_ARG_NONNULL ((1))); 1132_GL_CXXALIAS_RPL (strtod, double, (const char *str, char **endp)); 1133# else 1134# if !1 1135_GL_FUNCDECL_SYS (strtod, double, (const char *str, char **endp) 1136 _GL_ARG_NONNULL ((1))); 1137# endif 1138_GL_CXXALIAS_SYS (strtod, double, (const char *str, char **endp)); 1139# endif 1140_GL_CXXALIASWARN (strtod); 1141#elif defined GNULIB_POSIXCHECK 1142# undef strtod 1143# if HAVE_RAW_DECL_STRTOD 1144_GL_WARN_ON_USE (strtod, "strtod is unportable - " 1145 "use gnulib module strtod for portability"); 1146# endif 1147#endif 1148 1149#if 0 1150/* Parse a signed integer whose textual representation starts at STRING. 1151 The integer is expected to be in base BASE (2 <= BASE <= 36); if BASE == 0, 1152 it may be decimal or octal (with prefix "0") or hexadecimal (with prefix 1153 "0x"). 1154 If ENDPTR is not NULL, the address of the first byte after the integer is 1155 stored in *ENDPTR. 1156 Upon overflow, the return value is LLONG_MAX or LLONG_MIN, and errno is set 1157 to ERANGE. */ 1158# if !1 1159_GL_FUNCDECL_SYS (strtoll, long long, 1160 (const char *string, char **endptr, int base) 1161 _GL_ARG_NONNULL ((1))); 1162# endif 1163_GL_CXXALIAS_SYS (strtoll, long long, 1164 (const char *string, char **endptr, int base)); 1165_GL_CXXALIASWARN (strtoll); 1166#elif defined GNULIB_POSIXCHECK 1167# undef strtoll 1168# if HAVE_RAW_DECL_STRTOLL 1169_GL_WARN_ON_USE (strtoll, "strtoll is unportable - " 1170 "use gnulib module strtoll for portability"); 1171# endif 1172#endif 1173 1174#if 0 1175/* Parse an unsigned integer whose textual representation starts at STRING. 1176 The integer is expected to be in base BASE (2 <= BASE <= 36); if BASE == 0, 1177 it may be decimal or octal (with prefix "0") or hexadecimal (with prefix 1178 "0x"). 1179 If ENDPTR is not NULL, the address of the first byte after the integer is 1180 stored in *ENDPTR. 1181 Upon overflow, the return value is ULLONG_MAX, and errno is set to 1182 ERANGE. */ 1183# if !1 1184_GL_FUNCDECL_SYS (strtoull, unsigned long long, 1185 (const char *string, char **endptr, int base) 1186 _GL_ARG_NONNULL ((1))); 1187# endif 1188_GL_CXXALIAS_SYS (strtoull, unsigned long long, 1189 (const char *string, char **endptr, int base)); 1190_GL_CXXALIASWARN (strtoull); 1191#elif defined GNULIB_POSIXCHECK 1192# undef strtoull 1193# if HAVE_RAW_DECL_STRTOULL 1194_GL_WARN_ON_USE (strtoull, "strtoull is unportable - " 1195 "use gnulib module strtoull for portability"); 1196# endif 1197#endif 1198 1199#if 0 1200/* Unlock the slave side of the pseudo-terminal whose master side is specified 1201 by FD, so that it can be opened. */ 1202# if !1 1203_GL_FUNCDECL_SYS (unlockpt, int, (int fd)); 1204# endif 1205_GL_CXXALIAS_SYS (unlockpt, int, (int fd)); 1206_GL_CXXALIASWARN (unlockpt); 1207#elif defined GNULIB_POSIXCHECK 1208# undef unlockpt 1209# if HAVE_RAW_DECL_UNLOCKPT 1210_GL_WARN_ON_USE (unlockpt, "unlockpt is not portable - " 1211 "use gnulib module unlockpt for portability"); 1212# endif 1213#endif 1214 1215#if 1 1216/* Remove the variable NAME from the environment. */ 1217# if 0 1218# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1219# undef unsetenv 1220# define unsetenv rpl_unsetenv 1221# endif 1222_GL_FUNCDECL_RPL (unsetenv, int, (const char *name) _GL_ARG_NONNULL ((1))); 1223_GL_CXXALIAS_RPL (unsetenv, int, (const char *name)); 1224# else 1225# if !1 1226_GL_FUNCDECL_SYS (unsetenv, int, (const char *name) _GL_ARG_NONNULL ((1))); 1227# endif 1228_GL_CXXALIAS_SYS (unsetenv, int, (const char *name)); 1229# endif 1230# if !(0 && !1) 1231_GL_CXXALIASWARN (unsetenv); 1232# endif 1233#elif defined GNULIB_POSIXCHECK 1234# undef unsetenv 1235# if HAVE_RAW_DECL_UNSETENV 1236_GL_WARN_ON_USE (unsetenv, "unsetenv is unportable - " 1237 "use gnulib module unsetenv for portability"); 1238# endif 1239#endif 1240 1241/* Convert a wide character to a multibyte character. */ 1242#if 0 1243# if 0 1244# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1245# undef wctomb 1246# define wctomb rpl_wctomb 1247# endif 1248_GL_FUNCDECL_RPL (wctomb, int, (char *s, wchar_t wc)); 1249_GL_CXXALIAS_RPL (wctomb, int, (char *s, wchar_t wc)); 1250# else 1251_GL_CXXALIAS_SYS (wctomb, int, (char *s, wchar_t wc)); 1252# endif 1253_GL_CXXALIASWARN (wctomb); 1254#endif 1255 1256 1257#endif /* _GL_STDLIB_H */ 1258#endif /* _GL_STDLIB_H */ 1259#endif 1260