gnu/usr.bin/grep/libgreputils/stdlib.h

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