lib/string.in.h

   1 /* A GNU-like <string.h>.
   2
   3    Copyright (C) 1995-1996, 2001-2025 Free Software Foundation, Inc.
   4
   5    This file is free software: you can redistribute it and/or modify
   6    it under the terms of the GNU Lesser General Public License as
   7    published by the Free Software Foundation; either version 2.1 of the
   8    License, or (at your option) any later version.
   9
  10    This file is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public License
  16    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  17
  18 #if __GNUC__ >= 3
  19 @PRAGMA_SYSTEM_HEADER@
  20 #endif
  21 @PRAGMA_COLUMNS@
  22
  23 #if defined _@GUARD_PREFIX@_ALREADY_INCLUDING_STRING_H
  24 /* Special invocation convention:
  25    - On OS X/NetBSD we have a sequence of nested includes
  26        <string.h> -> <strings.h> -> "string.h"
  27      In this situation system _chk variants due to -D_FORTIFY_SOURCE
  28      might be used after any replacements defined here.  */
  29
  30 #@INCLUDE_NEXT@ @NEXT_STRING_H@
  31
  32 #else
  33 /* Normal invocation convention.  */
  34
  35 #ifndef _@GUARD_PREFIX@_STRING_H
  36
  37 #define _@GUARD_PREFIX@_ALREADY_INCLUDING_STRING_H
  38
  39 /* The include_next requires a split double-inclusion guard.  */
  40 #@INCLUDE_NEXT@ @NEXT_STRING_H@
  41
  42 #undef _@GUARD_PREFIX@_ALREADY_INCLUDING_STRING_H
  43
  44 #ifndef _@GUARD_PREFIX@_STRING_H
  45 #define _@GUARD_PREFIX@_STRING_H
  46
  47 /* This file uses _GL_ATTRIBUTE_DEALLOC, _GL_ATTRIBUTE_MALLOC,
  48    _GL_ATTRIBUTE_NOTHROW, _GL_ATTRIBUTE_PURE, GNULIB_POSIXCHECK,
  49    HAVE_RAW_DECL_*.  */
  50 #if !_GL_CONFIG_H_INCLUDED
  51  #error "Please include config.h first."
  52 #endif
  53
  54 /* NetBSD 5.0 mis-defines NULL.  */
  55 #include <stddef.h>
  56
  57 /* MirBSD defines mbslen as a macro.  */
  58 #if @GNULIB_MBSLEN@ && defined __MirBSD__
  59 # include <wchar.h>
  60 #endif
  61
  62 /* NetBSD 5.0 declares strsignal in <unistd.h>, not in <string.h>.  */
  63 /* But in any case avoid namespace pollution on glibc systems.  */
  64 #if (@GNULIB_STRSIGNAL@ || defined GNULIB_POSIXCHECK) && defined __NetBSD__ \
  65     && ! defined __GLIBC__
  66 # include <unistd.h>
  67 #endif
  68
  69 /* AIX 7.2 and Android 13 declare ffsl and ffsll in <strings.h>, not in
  70    <string.h>.  */
  71 /* But in any case avoid namespace pollution on glibc systems.  */
  72 #if ((@GNULIB_FFSL@ || @GNULIB_FFSLL@ || defined GNULIB_POSIXCHECK) \
  73      && (defined _AIX || defined __ANDROID__)) \
  74     && ! defined __GLIBC__
  75 # include <strings.h>
  76 #endif
  77
  78 /* _GL_ATTRIBUTE_DEALLOC (F, I) declares that the function returns pointers
  79    that can be freed by passing them as the Ith argument to the
  80    function F.  */
  81 #ifndef _GL_ATTRIBUTE_DEALLOC
  82 # if __GNUC__ >= 11 && !defined __clang__
  83 #  define _GL_ATTRIBUTE_DEALLOC(f, i) __attribute__ ((__malloc__ (f, i)))
  84 # else
  85 #  define _GL_ATTRIBUTE_DEALLOC(f, i)
  86 # endif
  87 #endif
  88
  89 /* _GL_ATTRIBUTE_DEALLOC_FREE declares that the function returns pointers that
  90    can be freed via 'free'; it can be used only after declaring 'free'.  */
  91 /* Applies to: functions.  Cannot be used on inline functions.  */
  92 #ifndef _GL_ATTRIBUTE_DEALLOC_FREE
  93 # if defined __cplusplus && defined __GNUC__ && !defined __clang__
  94 /* Work around GCC bug <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108231> */
  95 #  define _GL_ATTRIBUTE_DEALLOC_FREE \
  96      _GL_ATTRIBUTE_DEALLOC ((void (*) (void *)) free, 1)
  97 # else
  98 #  define _GL_ATTRIBUTE_DEALLOC_FREE \
  99      _GL_ATTRIBUTE_DEALLOC (free, 1)
 100 # endif
 101 #endif
 102
 103 /* _GL_ATTRIBUTE_MALLOC declares that the function returns a pointer to freshly
 104    allocated memory.  */
 105 /* Applies to: functions.  */
 106 #ifndef _GL_ATTRIBUTE_MALLOC
 107 # if __GNUC__ >= 3 || defined __clang__
 108 #  define _GL_ATTRIBUTE_MALLOC __attribute__ ((__malloc__))
 109 # else
 110 #  define _GL_ATTRIBUTE_MALLOC
 111 # endif
 112 #endif
 113
 114 /* _GL_ATTRIBUTE_NOTHROW declares that the function does not throw exceptions.
 115  */
 116 #ifndef _GL_ATTRIBUTE_NOTHROW
 117 # if defined __cplusplus
 118 #  if (__GNUC__ + (__GNUC_MINOR__ >= 8) > 2) || __clang_major__ >= 4
 119 #   if __cplusplus >= 201103L
 120 #    define _GL_ATTRIBUTE_NOTHROW noexcept (true)
 121 #   else
 122 #    define _GL_ATTRIBUTE_NOTHROW throw ()
 123 #   endif
 124 #  else
 125 #   define _GL_ATTRIBUTE_NOTHROW
 126 #  endif
 127 # else
 128 #  if (__GNUC__ + (__GNUC_MINOR__ >= 3) > 3) || defined __clang__
 129 #   define _GL_ATTRIBUTE_NOTHROW __attribute__ ((__nothrow__))
 130 #  else
 131 #   define _GL_ATTRIBUTE_NOTHROW
 132 #  endif
 133 # endif
 134 #endif
 135
 136 /* The __attribute__ feature is available in gcc versions 2.5 and later.
 137    The attribute __pure__ was added in gcc 2.96.  */
 138 #ifndef _GL_ATTRIBUTE_PURE
 139 # if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96) || defined __clang__
 140 #  define _GL_ATTRIBUTE_PURE __attribute__ ((__pure__))
 141 # else
 142 #  define _GL_ATTRIBUTE_PURE /* empty */
 143 # endif
 144 #endif
 145
 146 /* The definitions of _GL_FUNCDECL_RPL etc. are copied here.  */
 147
 148 /* The definition of _GL_ARG_NONNULL is copied here.  */
 149
 150 /* The definition of _GL_WARN_ON_USE is copied here.  */
 151
 152 /* Make _GL_ATTRIBUTE_DEALLOC_FREE work, even though <stdlib.h> may not have
 153    been included yet.  */
 154 #if @GNULIB_FREE_POSIX@
 155 # if (@REPLACE_FREE@ && !defined free \
 156       && !(defined __cplusplus && defined GNULIB_NAMESPACE))
 157 /* We can't do '#define free rpl_free' here.  */
 158 #  if defined __cplusplus && (__GLIBC__ + (__GLIBC_MINOR__ >= 14) > 2)
 159 _GL_EXTERN_C void rpl_free (void *) _GL_ATTRIBUTE_NOTHROW;
 160 #  else
 161 _GL_EXTERN_C void rpl_free (void *);
 162 #  endif
 163 #  undef _GL_ATTRIBUTE_DEALLOC_FREE
 164 #  define _GL_ATTRIBUTE_DEALLOC_FREE _GL_ATTRIBUTE_DEALLOC (rpl_free, 1)
 165 # else
 166 #  if defined _MSC_VER && !defined free
 167 _GL_EXTERN_C
 168 #   if defined _DLL
 169      __declspec (dllimport)
 170 #   endif
 171      void __cdecl free (void *);
 172 #  else
 173 #   if defined __cplusplus && (__GLIBC__ + (__GLIBC_MINOR__ >= 14) > 2)
 174 _GL_EXTERN_C void free (void *) _GL_ATTRIBUTE_NOTHROW;
 175 #   else
 176 _GL_EXTERN_C void free (void *);
 177 #   endif
 178 #  endif
 179 # endif
 180 #else
 181 # if defined _MSC_VER && !defined free
 182 _GL_EXTERN_C
 183 #   if defined _DLL
 184      __declspec (dllimport)
 185 #   endif
 186      void __cdecl free (void *);
 187 # else
 188 #  if defined __cplusplus && (__GLIBC__ + (__GLIBC_MINOR__ >= 14) > 2)
 189 _GL_EXTERN_C void free (void *) _GL_ATTRIBUTE_NOTHROW;
 190 #  else
 191 _GL_EXTERN_C void free (void *);
 192 #  endif
 193 # endif
 194 #endif
 195
 196 /* Clear a block of memory.  The compiler will not delete a call to
 197    this function, even if the block is dead after the call.  */
 198 #if @GNULIB_EXPLICIT_BZERO@
 199 # if ! @HAVE_EXPLICIT_BZERO@
 200 _GL_FUNCDECL_SYS (explicit_bzero, void,
 201                   (void *__dest, size_t __n), _GL_ARG_NONNULL ((1)));
 202 # endif
 203 _GL_CXXALIAS_SYS (explicit_bzero, void, (void *__dest, size_t __n));
 204 _GL_CXXALIASWARN (explicit_bzero);
 205 #elif defined GNULIB_POSIXCHECK
 206 # undef explicit_bzero
 207 # if HAVE_RAW_DECL_EXPLICIT_BZERO
 208 _GL_WARN_ON_USE (explicit_bzero, "explicit_bzero is unportable - "
 209                  "use gnulib module explicit_bzero for portability");
 210 # endif
 211 #endif
 212
 213 /* Find the index of the least-significant set bit.  */
 214 #if @GNULIB_FFSL@
 215 # if !@HAVE_FFSL@
 216 _GL_FUNCDECL_SYS (ffsl, int, (long int i), );
 217 # endif
 218 _GL_CXXALIAS_SYS (ffsl, int, (long int i));
 219 _GL_CXXALIASWARN (ffsl);
 220 #elif defined GNULIB_POSIXCHECK
 221 # undef ffsl
 222 # if HAVE_RAW_DECL_FFSL
 223 _GL_WARN_ON_USE (ffsl, "ffsl is not portable - use the ffsl module");
 224 # endif
 225 #endif
 226
 227
 228 /* Find the index of the least-significant set bit.  */
 229 #if @GNULIB_FFSLL@
 230 # if @REPLACE_FFSLL@
 231 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 232 #   define ffsll rpl_ffsll
 233 #  endif
 234 _GL_FUNCDECL_RPL (ffsll, int, (long long int i), );
 235 _GL_CXXALIAS_RPL (ffsll, int, (long long int i));
 236 # else
 237 #  if !@HAVE_FFSLL@
 238 _GL_FUNCDECL_SYS (ffsll, int, (long long int i), );
 239 #  endif
 240 _GL_CXXALIAS_SYS (ffsll, int, (long long int i));
 241 # endif
 242 _GL_CXXALIASWARN (ffsll);
 243 #elif defined GNULIB_POSIXCHECK
 244 # undef ffsll
 245 # if HAVE_RAW_DECL_FFSLL
 246 _GL_WARN_ON_USE (ffsll, "ffsll is not portable - use the ffsll module");
 247 # endif
 248 #endif
 249
 250
 251 #if @GNULIB_MDA_MEMCCPY@
 252 /* On native Windows, map 'memccpy' to '_memccpy', so that -loldnames is not
 253    required.  In C++ with GNULIB_NAMESPACE, avoid differences between
 254    platforms by defining GNULIB_NAMESPACE::memccpy always.  */
 255 # if defined _WIN32 && !defined __CYGWIN__
 256 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 257 #   undef memccpy
 258 #   define memccpy _memccpy
 259 #  endif
 260 _GL_CXXALIAS_MDA (memccpy, void *,
 261                   (void *dest, const void *src, int c, size_t n));
 262 # else
 263 _GL_CXXALIAS_SYS (memccpy, void *,
 264                   (void *dest, const void *src, int c, size_t n));
 265 # endif
 266 _GL_CXXALIASWARN (memccpy);
 267 #endif
 268
 269
 270 /* Return the first instance of C within N bytes of S, or NULL.  */
 271 #if @GNULIB_MEMCHR@
 272 # if @REPLACE_MEMCHR@
 273 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 274 #   undef memchr
 275 #   define memchr rpl_memchr
 276 #  endif
 277 _GL_FUNCDECL_RPL (memchr, void *, (void const *__s, int __c, size_t __n),
 278                                   _GL_ATTRIBUTE_PURE
 279                                   _GL_ARG_NONNULL ((1)));
 280 _GL_CXXALIAS_RPL (memchr, void *, (void const *__s, int __c, size_t __n));
 281 # else
 282   /* On some systems, this function is defined as an overloaded function:
 283        extern "C" { const void * std::memchr (const void *, int, size_t); }
 284        extern "C++" { void * std::memchr (void *, int, size_t); }  */
 285 _GL_CXXALIAS_SYS_CAST2 (memchr,
 286                         void *, (void const *__s, int __c, size_t __n),
 287                         void const *, (void const *__s, int __c, size_t __n));
 288 # endif
 289 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
 290      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4) \
 291          || defined __clang__)
 292 _GL_CXXALIASWARN1 (memchr, void *,
 293                    (void *__s, int __c, size_t __n)
 294                    _GL_ATTRIBUTE_NOTHROW);
 295 _GL_CXXALIASWARN1 (memchr, void const *,
 296                    (void const *__s, int __c, size_t __n)
 297                    _GL_ATTRIBUTE_NOTHROW);
 298 # elif __GLIBC__ >= 2
 299 _GL_CXXALIASWARN (memchr);
 300 # endif
 301 #elif defined GNULIB_POSIXCHECK
 302 # undef memchr
 303 /* Assume memchr is always declared.  */
 304 _GL_WARN_ON_USE (memchr, "memchr has platform-specific bugs - "
 305                  "use gnulib module memchr for portability" );
 306 #endif
 307
 308 /* Return the first occurrence of NEEDLE in HAYSTACK.  */
 309 #if @GNULIB_MEMMEM@
 310 # if @REPLACE_MEMMEM@
 311 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 312 #   define memmem rpl_memmem
 313 #  endif
 314 _GL_FUNCDECL_RPL (memmem, void *,
 315                   (void const *__haystack, size_t __haystack_len,
 316                    void const *__needle, size_t __needle_len),
 317                   _GL_ATTRIBUTE_PURE
 318                   _GL_ARG_NONNULL ((1, 3)));
 319 _GL_CXXALIAS_RPL (memmem, void *,
 320                   (void const *__haystack, size_t __haystack_len,
 321                    void const *__needle, size_t __needle_len));
 322 # else
 323 #  if ! @HAVE_DECL_MEMMEM@
 324 _GL_FUNCDECL_SYS (memmem, void *,
 325                   (void const *__haystack, size_t __haystack_len,
 326                    void const *__needle, size_t __needle_len),
 327                   _GL_ATTRIBUTE_PURE
 328                   _GL_ARG_NONNULL ((1, 3)));
 329 #  endif
 330 _GL_CXXALIAS_SYS (memmem, void *,
 331                   (void const *__haystack, size_t __haystack_len,
 332                    void const *__needle, size_t __needle_len));
 333 # endif
 334 _GL_CXXALIASWARN (memmem);
 335 #elif defined GNULIB_POSIXCHECK
 336 # undef memmem
 337 # if HAVE_RAW_DECL_MEMMEM
 338 _GL_WARN_ON_USE (memmem, "memmem is unportable and often quadratic - "
 339                  "use gnulib module memmem-simple for portability, "
 340                  "and module memmem for speed" );
 341 # endif
 342 #endif
 343
 344 /* Copy N bytes of SRC to DEST, return pointer to bytes after the
 345    last written byte.  */
 346 #if @GNULIB_MEMPCPY@
 347 # if @REPLACE_MEMPCPY@
 348 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 349 #   undef mempcpy
 350 #   define mempcpy rpl_mempcpy
 351 #  endif
 352 _GL_FUNCDECL_RPL (mempcpy, void *,
 353                   (void *restrict __dest, void const *restrict __src,
 354                    size_t __n),
 355                   _GL_ARG_NONNULL ((1, 2)));
 356 _GL_CXXALIAS_RPL (mempcpy, void *,
 357                   (void *restrict __dest, void const *restrict __src,
 358                    size_t __n));
 359 # else
 360 #  if !@HAVE_MEMPCPY@
 361 _GL_FUNCDECL_SYS (mempcpy, void *,
 362                   (void *restrict __dest, void const *restrict __src,
 363                    size_t __n),
 364                   _GL_ARG_NONNULL ((1, 2)));
 365 #  endif
 366 _GL_CXXALIAS_SYS (mempcpy, void *,
 367                   (void *restrict __dest, void const *restrict __src,
 368                    size_t __n));
 369 # endif
 370 # if __GLIBC__ >= 2
 371 _GL_CXXALIASWARN (mempcpy);
 372 # endif
 373 #elif defined GNULIB_POSIXCHECK
 374 # undef mempcpy
 375 # if HAVE_RAW_DECL_MEMPCPY
 376 _GL_WARN_ON_USE (mempcpy, "mempcpy is unportable - "
 377                  "use gnulib module mempcpy for portability");
 378 # endif
 379 #endif
 380
 381 /* Search backwards through a block for a byte (specified as an int).  */
 382 #if @GNULIB_MEMRCHR@
 383 # if ! @HAVE_DECL_MEMRCHR@
 384 _GL_FUNCDECL_SYS (memrchr, void *, (void const *, int, size_t),
 385                                    _GL_ATTRIBUTE_PURE
 386                                    _GL_ARG_NONNULL ((1)));
 387 # endif
 388   /* On some systems, this function is defined as an overloaded function:
 389        extern "C++" { const void * std::memrchr (const void *, int, size_t); }
 390        extern "C++" { void * std::memrchr (void *, int, size_t); }  */
 391 _GL_CXXALIAS_SYS_CAST2 (memrchr,
 392                         void *, (void const *, int, size_t),
 393                         void const *, (void const *, int, size_t));
 394 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
 395      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4) \
 396          || defined __clang__)
 397 _GL_CXXALIASWARN1 (memrchr, void *,
 398                    (void *, int, size_t)
 399                    _GL_ATTRIBUTE_NOTHROW);
 400 _GL_CXXALIASWARN1 (memrchr, void const *,
 401                    (void const *, int, size_t)
 402                    _GL_ATTRIBUTE_NOTHROW);
 403 # elif __GLIBC__ >= 2
 404 _GL_CXXALIASWARN (memrchr);
 405 # endif
 406 #elif defined GNULIB_POSIXCHECK
 407 # undef memrchr
 408 # if HAVE_RAW_DECL_MEMRCHR
 409 _GL_WARN_ON_USE (memrchr, "memrchr is unportable - "
 410                  "use gnulib module memrchr for portability");
 411 # endif
 412 #endif
 413
 414 /* Overwrite a block of memory.  The compiler will not optimize
 415    effects away, even if the block is dead after the call.  */
 416 #if @GNULIB_MEMSET_EXPLICIT@
 417 # if @REPLACE_MEMSET_EXPLICIT@
 418 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 419 #   undef memset_explicit
 420 #   define memset_explicit rpl_memset_explicit
 421 #  endif
 422 _GL_FUNCDECL_RPL (memset_explicit, void *,
 423                   (void *__dest, int __c, size_t __n), _GL_ARG_NONNULL ((1)));
 424 _GL_CXXALIAS_RPL (memset_explicit, void *, (void *__dest, int __c, size_t __n));
 425 # else
 426 #  if !@HAVE_MEMSET_EXPLICIT@
 427 _GL_FUNCDECL_SYS (memset_explicit, void *,
 428                   (void *__dest, int __c, size_t __n), _GL_ARG_NONNULL ((1)));
 429 #  endif
 430 _GL_CXXALIAS_SYS (memset_explicit, void *, (void *__dest, int __c, size_t __n));
 431 # endif
 432 _GL_CXXALIASWARN (memset_explicit);
 433 #elif defined GNULIB_POSIXCHECK
 434 # undef memset_explicit
 435 # if HAVE_RAW_DECL_MEMSET_EXPLICIT
 436 _GL_WARN_ON_USE (memset_explicit, "memset_explicit is unportable - "
 437                  "use gnulib module memset_explicit for portability");
 438 # endif
 439 #endif
 440
 441 /* Find the first occurrence of C in S.  More efficient than
 442    memchr(S,C,N), at the expense of undefined behavior if C does not
 443    occur within N bytes.  */
 444 #if @GNULIB_RAWMEMCHR@
 445 # if ! @HAVE_RAWMEMCHR@
 446 _GL_FUNCDECL_SYS (rawmemchr, void *, (void const *__s, int __c_in),
 447                                      _GL_ATTRIBUTE_PURE
 448                                      _GL_ARG_NONNULL ((1)));
 449 # endif
 450   /* On some systems, this function is defined as an overloaded function:
 451        extern "C++" { const void * std::rawmemchr (const void *, int); }
 452        extern "C++" { void * std::rawmemchr (void *, int); }  */
 453 _GL_CXXALIAS_SYS_CAST2 (rawmemchr,
 454                         void *, (void const *__s, int __c_in),
 455                         void const *, (void const *__s, int __c_in));
 456 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
 457      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4) \
 458          || defined __clang__)
 459 _GL_CXXALIASWARN1 (rawmemchr, void *,
 460                    (void *__s, int __c_in)
 461                    _GL_ATTRIBUTE_NOTHROW);
 462 _GL_CXXALIASWARN1 (rawmemchr, void const *,
 463                    (void const *__s, int __c_in)
 464                    _GL_ATTRIBUTE_NOTHROW);
 465 # else
 466 _GL_CXXALIASWARN (rawmemchr);
 467 # endif
 468 #elif defined GNULIB_POSIXCHECK
 469 # undef rawmemchr
 470 # if HAVE_RAW_DECL_RAWMEMCHR
 471 _GL_WARN_ON_USE (rawmemchr, "rawmemchr is unportable - "
 472                  "use gnulib module rawmemchr for portability");
 473 # endif
 474 #endif
 475
 476 /* Copy SRC to DST, returning the address of the terminating '\0' in DST.  */
 477 #if @GNULIB_STPCPY@
 478 # if @REPLACE_STPCPY@
 479 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 480 #   undef stpcpy
 481 #   define stpcpy rpl_stpcpy
 482 #  endif
 483 _GL_FUNCDECL_RPL (stpcpy, char *,
 484                   (char *restrict __dst, char const *restrict __src),
 485                   _GL_ARG_NONNULL ((1, 2)));
 486 _GL_CXXALIAS_RPL (stpcpy, char *,
 487                   (char *restrict __dst, char const *restrict __src));
 488 # else
 489 #  if !@HAVE_STPCPY@
 490 _GL_FUNCDECL_SYS (stpcpy, char *,
 491                   (char *restrict __dst, char const *restrict __src),
 492                   _GL_ARG_NONNULL ((1, 2)));
 493 #  endif
 494 _GL_CXXALIAS_SYS (stpcpy, char *,
 495                   (char *restrict __dst, char const *restrict __src));
 496 # endif
 497 # if __GLIBC__ >= 2
 498 _GL_CXXALIASWARN (stpcpy);
 499 # endif
 500 #elif defined GNULIB_POSIXCHECK
 501 # undef stpcpy
 502 # if HAVE_RAW_DECL_STPCPY
 503 _GL_WARN_ON_USE (stpcpy, "stpcpy is unportable - "
 504                  "use gnulib module stpcpy for portability");
 505 # endif
 506 #endif
 507
 508 /* Copy no more than N bytes of SRC to DST, returning a pointer past the
 509    last non-NUL byte written into DST.  */
 510 #if @GNULIB_STPNCPY@
 511 # if @REPLACE_STPNCPY@
 512 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 513 #   undef stpncpy
 514 #   define stpncpy rpl_stpncpy
 515 #  endif
 516 _GL_FUNCDECL_RPL (stpncpy, char *,
 517                   (char *restrict __dst, char const *restrict __src,
 518                    size_t __n),
 519                   _GL_ARG_NONNULL ((1, 2)));
 520 _GL_CXXALIAS_RPL (stpncpy, char *,
 521                   (char *restrict __dst, char const *restrict __src,
 522                    size_t __n));
 523 # else
 524 #  if ! @HAVE_STPNCPY@
 525 _GL_FUNCDECL_SYS (stpncpy, char *,
 526                   (char *restrict __dst, char const *restrict __src,
 527                    size_t __n),
 528                   _GL_ARG_NONNULL ((1, 2)));
 529 #  endif
 530 _GL_CXXALIAS_SYS (stpncpy, char *,
 531                   (char *restrict __dst, char const *restrict __src,
 532                    size_t __n));
 533 # endif
 534 # if __GLIBC__ >= 2
 535 _GL_CXXALIASWARN (stpncpy);
 536 # endif
 537 #elif defined GNULIB_POSIXCHECK
 538 # undef stpncpy
 539 # if HAVE_RAW_DECL_STPNCPY
 540 _GL_WARN_ON_USE (stpncpy, "stpncpy is unportable - "
 541                  "use gnulib module stpncpy for portability");
 542 # endif
 543 #endif
 544
 545 #if defined GNULIB_POSIXCHECK
 546 /* strchr() does not work with multibyte strings if the locale encoding is
 547    GB18030 and the character to be searched is a digit.  */
 548 # undef strchr
 549 /* Assume strchr is always declared.  */
 550 _GL_WARN_ON_USE_CXX (strchr,
 551                      const char *, char *, (const char *, int),
 552                      "strchr cannot work correctly on character strings "
 553                      "in some multibyte locales - "
 554                      "use mbschr if you care about internationalization");
 555 #endif
 556
 557 /* Find the first occurrence of C in S or the final NUL byte.  */
 558 #if @GNULIB_STRCHRNUL@
 559 # if @REPLACE_STRCHRNUL@
 560 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 561 #   define strchrnul rpl_strchrnul
 562 #  endif
 563 _GL_FUNCDECL_RPL (strchrnul, char *, (const char *__s, int __c_in),
 564                                      _GL_ATTRIBUTE_PURE
 565                                      _GL_ARG_NONNULL ((1)));
 566 _GL_CXXALIAS_RPL (strchrnul, char *,
 567                   (const char *str, int ch));
 568 # else
 569 #  if ! @HAVE_STRCHRNUL@
 570 _GL_FUNCDECL_SYS (strchrnul, char *, (char const *__s, int __c_in),
 571                                      _GL_ATTRIBUTE_PURE
 572                                      _GL_ARG_NONNULL ((1)));
 573 #  endif
 574   /* On some systems, this function is defined as an overloaded function:
 575        extern "C++" { const char * std::strchrnul (const char *, int); }
 576        extern "C++" { char * std::strchrnul (char *, int); }  */
 577 _GL_CXXALIAS_SYS_CAST2 (strchrnul,
 578                         char *, (char const *__s, int __c_in),
 579                         char const *, (char const *__s, int __c_in));
 580 # endif
 581 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
 582      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4) \
 583          || defined __clang__)
 584 _GL_CXXALIASWARN1 (strchrnul, char *,
 585                    (char *__s, int __c_in)
 586                    _GL_ATTRIBUTE_NOTHROW);
 587 _GL_CXXALIASWARN1 (strchrnul, char const *,
 588                    (char const *__s, int __c_in)
 589                    _GL_ATTRIBUTE_NOTHROW);
 590 # elif __GLIBC__ >= 2
 591 _GL_CXXALIASWARN (strchrnul);
 592 # endif
 593 #elif defined GNULIB_POSIXCHECK
 594 # undef strchrnul
 595 # if HAVE_RAW_DECL_STRCHRNUL
 596 _GL_WARN_ON_USE (strchrnul, "strchrnul is unportable - "
 597                  "use gnulib module strchrnul for portability");
 598 # endif
 599 #endif
 600
 601 /* Duplicate S, returning an identical malloc'd string.  */
 602 #if @GNULIB_STRDUP@
 603 # if @REPLACE_STRDUP@
 604 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 605 #   undef strdup
 606 #   define strdup rpl_strdup
 607 #  endif
 608 _GL_FUNCDECL_RPL (strdup, char *,
 609                   (char const *__s),
 610                   _GL_ARG_NONNULL ((1))
 611                   _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
 612 _GL_CXXALIAS_RPL (strdup, char *, (char const *__s));
 613 # elif defined _WIN32 && !defined __CYGWIN__
 614 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 615 #   undef strdup
 616 #   define strdup _strdup
 617 #  endif
 618 _GL_CXXALIAS_MDA (strdup, char *, (char const *__s));
 619 # else
 620 #  if defined __cplusplus && defined GNULIB_NAMESPACE && defined strdup
 621     /* strdup exists as a function and as a macro.  Get rid of the macro.  */
 622 #   undef strdup
 623 #  endif
 624 #  if (!@HAVE_DECL_STRDUP@ || (__GNUC__ >= 11 && !defined __clang__)) \
 625       && !defined strdup
 626 #   if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
 627 _GL_FUNCDECL_SYS (strdup, char *,
 628                   (char const *__s),
 629                   _GL_ARG_NONNULL ((1))
 630                   _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
 631                   _GL_ATTRIBUTE_NOTHROW;
 632 #   else
 633 _GL_FUNCDECL_SYS (strdup, char *,
 634                   (char const *__s),
 635                   _GL_ARG_NONNULL ((1))
 636                   _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
 637 #   endif
 638 #  endif
 639 _GL_CXXALIAS_SYS (strdup, char *, (char const *__s));
 640 # endif
 641 _GL_CXXALIASWARN (strdup);
 642 #else
 643 # if (__GNUC__ >= 11 && !defined __clang__) && !defined strdup
 644 /* For -Wmismatched-dealloc: Associate strdup with free or rpl_free.  */
 645 #  if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
 646 _GL_FUNCDECL_SYS (strdup, char *,
 647                   (char const *__s),
 648                   _GL_ARG_NONNULL ((1))
 649                   _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
 650                   _GL_ATTRIBUTE_NOTHROW;
 651 #  else
 652 _GL_FUNCDECL_SYS (strdup, char *,
 653                   (char const *__s),
 654                   _GL_ARG_NONNULL ((1))
 655                   _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
 656 #  endif
 657 # endif
 658 # if defined GNULIB_POSIXCHECK
 659 #  undef strdup
 660 #  if HAVE_RAW_DECL_STRDUP
 661 _GL_WARN_ON_USE (strdup, "strdup is unportable - "
 662                  "use gnulib module strdup for portability");
 663 #  endif
 664 # elif @GNULIB_MDA_STRDUP@
 665 /* On native Windows, map 'creat' to '_creat', so that -loldnames is not
 666    required.  In C++ with GNULIB_NAMESPACE, avoid differences between
 667    platforms by defining GNULIB_NAMESPACE::strdup always.  */
 668 #  if defined _WIN32 && !defined __CYGWIN__
 669 #   if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 670 #    undef strdup
 671 #    define strdup _strdup
 672 #   endif
 673 _GL_CXXALIAS_MDA (strdup, char *, (char const *__s));
 674 #  else
 675 #   if defined __cplusplus && defined GNULIB_NAMESPACE && defined strdup
 676 #    undef strdup
 677 #   endif
 678 _GL_CXXALIAS_SYS (strdup, char *, (char const *__s));
 679 #  endif
 680 _GL_CXXALIASWARN (strdup);
 681 # endif
 682 #endif
 683
 684 /* Append no more than N characters from SRC onto DEST.  */
 685 #if @GNULIB_STRNCAT@
 686 # if @REPLACE_STRNCAT@
 687 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 688 #   undef strncat
 689 #   define strncat rpl_strncat
 690 #  endif
 691 _GL_FUNCDECL_RPL (strncat, char *,
 692                   (char *restrict dest, const char *restrict src, size_t n),
 693                   _GL_ARG_NONNULL ((1, 2)));
 694 _GL_CXXALIAS_RPL (strncat, char *,
 695                   (char *restrict dest, const char *restrict src, size_t n));
 696 # else
 697 _GL_CXXALIAS_SYS (strncat, char *,
 698                   (char *restrict dest, const char *restrict src, size_t n));
 699 # endif
 700 # if __GLIBC__ >= 2
 701 _GL_CXXALIASWARN (strncat);
 702 # endif
 703 #elif defined GNULIB_POSIXCHECK
 704 # undef strncat
 705 # if HAVE_RAW_DECL_STRNCAT
 706 _GL_WARN_ON_USE (strncat, "strncat is unportable - "
 707                  "use gnulib module strncat for portability");
 708 # endif
 709 #endif
 710
 711 /* Return a newly allocated copy of at most N bytes of STRING.  */
 712 #if @GNULIB_STRNDUP@
 713 # if @REPLACE_STRNDUP@
 714 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 715 #   undef strndup
 716 #   define strndup rpl_strndup
 717 #  endif
 718 _GL_FUNCDECL_RPL (strndup, char *,
 719                   (char const *__s, size_t __n),
 720                   _GL_ARG_NONNULL ((1))
 721                   _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
 722 _GL_CXXALIAS_RPL (strndup, char *, (char const *__s, size_t __n));
 723 # else
 724 #  if !@HAVE_DECL_STRNDUP@ \
 725       || ((__GNUC__ >= 11 && !defined __clang__) && !defined strndup)
 726 #   if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
 727 _GL_FUNCDECL_SYS (strndup, char *,
 728                   (char const *__s, size_t __n),
 729                   _GL_ARG_NONNULL ((1))
 730                   _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
 731                   _GL_ATTRIBUTE_NOTHROW;
 732 #   else
 733 _GL_FUNCDECL_SYS (strndup, char *,
 734                   (char const *__s, size_t __n),
 735                   _GL_ARG_NONNULL ((1))
 736                   _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
 737 #   endif
 738 #  endif
 739 _GL_CXXALIAS_SYS (strndup, char *, (char const *__s, size_t __n));
 740 # endif
 741 _GL_CXXALIASWARN (strndup);
 742 #else
 743 # if (__GNUC__ >= 11 && !defined __clang__) && !defined strndup
 744 /* For -Wmismatched-dealloc: Associate strndup with free or rpl_free.  */
 745 #  if __GLIBC__ + (__GLIBC_MINOR__ >= 2) > 2
 746 _GL_FUNCDECL_SYS (strndup, char *,
 747                   (char const *__s, size_t __n),
 748                   _GL_ARG_NONNULL ((1))
 749                   _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE)
 750                   _GL_ATTRIBUTE_NOTHROW;
 751 #  else
 752 _GL_FUNCDECL_SYS (strndup, char *,
 753                   (char const *__s, size_t __n),
 754                   _GL_ARG_NONNULL ((1))
 755                   _GL_ATTRIBUTE_MALLOC _GL_ATTRIBUTE_DEALLOC_FREE);
 756 #  endif
 757 # endif
 758 # if defined GNULIB_POSIXCHECK
 759 #  undef strndup
 760 #  if HAVE_RAW_DECL_STRNDUP
 761 _GL_WARN_ON_USE (strndup, "strndup is unportable - "
 762                  "use gnulib module strndup for portability");
 763 #  endif
 764 # endif
 765 #endif
 766
 767 /* Find the length (number of bytes) of STRING, but scan at most
 768    MAXLEN bytes.  If no '\0' terminator is found in that many bytes,
 769    return MAXLEN.  */
 770 #if @GNULIB_STRNLEN@
 771 # if @REPLACE_STRNLEN@
 772 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 773 #   undef strnlen
 774 #   define strnlen rpl_strnlen
 775 #  endif
 776 _GL_FUNCDECL_RPL (strnlen, size_t, (char const *__s, size_t __maxlen),
 777                                    _GL_ATTRIBUTE_PURE
 778                                    _GL_ARG_NONNULL ((1)));
 779 _GL_CXXALIAS_RPL (strnlen, size_t, (char const *__s, size_t __maxlen));
 780 # else
 781 #  if ! @HAVE_DECL_STRNLEN@
 782 _GL_FUNCDECL_SYS (strnlen, size_t, (char const *__s, size_t __maxlen),
 783                                    _GL_ATTRIBUTE_PURE
 784                                    _GL_ARG_NONNULL ((1)));
 785 #  endif
 786 _GL_CXXALIAS_SYS (strnlen, size_t, (char const *__s, size_t __maxlen));
 787 # endif
 788 _GL_CXXALIASWARN (strnlen);
 789 #elif defined GNULIB_POSIXCHECK
 790 # undef strnlen
 791 # if HAVE_RAW_DECL_STRNLEN
 792 _GL_WARN_ON_USE (strnlen, "strnlen is unportable - "
 793                  "use gnulib module strnlen for portability");
 794 # endif
 795 #endif
 796
 797 #if defined GNULIB_POSIXCHECK
 798 /* strcspn() assumes the second argument is a list of single-byte characters.
 799    Even in this simple case, it does not work with multibyte strings if the
 800    locale encoding is GB18030 and one of the characters to be searched is a
 801    digit.  */
 802 # undef strcspn
 803 /* Assume strcspn is always declared.  */
 804 _GL_WARN_ON_USE (strcspn, "strcspn cannot work correctly on character strings "
 805                  "in multibyte locales - "
 806                  "use mbscspn if you care about internationalization");
 807 #endif
 808
 809 /* Find the first occurrence in S of any character in ACCEPT.  */
 810 #if @GNULIB_STRPBRK@
 811 # if ! @HAVE_STRPBRK@
 812 _GL_FUNCDECL_SYS (strpbrk, char *, (char const *__s, char const *__accept),
 813                                    _GL_ATTRIBUTE_PURE
 814                                    _GL_ARG_NONNULL ((1, 2)));
 815 # endif
 816   /* On some systems, this function is defined as an overloaded function:
 817        extern "C" { const char * strpbrk (const char *, const char *); }
 818        extern "C++" { char * strpbrk (char *, const char *); }  */
 819 _GL_CXXALIAS_SYS_CAST2 (strpbrk,
 820                         char *, (char const *__s, char const *__accept),
 821                         const char *, (char const *__s, char const *__accept));
 822 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
 823      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4) \
 824          || defined __clang__)
 825 _GL_CXXALIASWARN1 (strpbrk, char *,
 826                    (char *__s, char const *__accept)
 827                    _GL_ATTRIBUTE_NOTHROW);
 828 _GL_CXXALIASWARN1 (strpbrk, char const *,
 829                    (char const *__s, char const *__accept)
 830                    _GL_ATTRIBUTE_NOTHROW);
 831 # elif __GLIBC__ >= 2
 832 _GL_CXXALIASWARN (strpbrk);
 833 # endif
 834 # if defined GNULIB_POSIXCHECK
 835 /* strpbrk() assumes the second argument is a list of single-byte characters.
 836    Even in this simple case, it does not work with multibyte strings if the
 837    locale encoding is GB18030 and one of the characters to be searched is a
 838    digit.  */
 839 #  undef strpbrk
 840 _GL_WARN_ON_USE_CXX (strpbrk,
 841                      const char *, char *, (const char *, const char *),
 842                      "strpbrk cannot work correctly on character strings "
 843                      "in multibyte locales - "
 844                      "use mbspbrk if you care about internationalization");
 845 # endif
 846 #elif defined GNULIB_POSIXCHECK
 847 # undef strpbrk
 848 # if HAVE_RAW_DECL_STRPBRK
 849 _GL_WARN_ON_USE_CXX (strpbrk,
 850                      const char *, char *, (const char *, const char *),
 851                      "strpbrk is unportable - "
 852                      "use gnulib module strpbrk for portability");
 853 # endif
 854 #endif
 855
 856 #if defined GNULIB_POSIXCHECK
 857 /* strspn() assumes the second argument is a list of single-byte characters.
 858    Even in this simple case, it cannot work with multibyte strings.  */
 859 # undef strspn
 860 /* Assume strspn is always declared.  */
 861 _GL_WARN_ON_USE (strspn, "strspn cannot work correctly on character strings "
 862                  "in multibyte locales - "
 863                  "use mbsspn if you care about internationalization");
 864 #endif
 865
 866 #if defined GNULIB_POSIXCHECK
 867 /* strrchr() does not work with multibyte strings if the locale encoding is
 868    GB18030 and the character to be searched is a digit.  */
 869 # undef strrchr
 870 /* Assume strrchr is always declared.  */
 871 _GL_WARN_ON_USE_CXX (strrchr,
 872                      const char *, char *, (const char *, int),
 873                      "strrchr cannot work correctly on character strings "
 874                      "in some multibyte locales - "
 875                      "use mbsrchr if you care about internationalization");
 876 #endif
 877
 878 /* Search the next delimiter (char listed in DELIM) starting at *STRINGP.
 879    If one is found, overwrite it with a NUL, and advance *STRINGP
 880    to point to the next char after it.  Otherwise, set *STRINGP to NULL.
 881    If *STRINGP was already NULL, nothing happens.
 882    Return the old value of *STRINGP.
 883
 884    This is a variant of strtok() that is multithread-safe and supports
 885    empty fields.
 886
 887    Caveat: It modifies the original string.
 888    Caveat: These functions cannot be used on constant strings.
 889    Caveat: The identity of the delimiting character is lost.
 890    Caveat: It doesn't work with multibyte strings unless all of the delimiter
 891            characters are ASCII characters < 0x30.
 892
 893    See also strtok_r().  */
 894 #if @GNULIB_STRSEP@
 895 # if ! @HAVE_STRSEP@
 896 _GL_FUNCDECL_SYS (strsep, char *,
 897                   (char **restrict __stringp, char const *restrict __delim),
 898                   _GL_ARG_NONNULL ((1, 2)));
 899 # endif
 900 _GL_CXXALIAS_SYS (strsep, char *,
 901                   (char **restrict __stringp, char const *restrict __delim));
 902 _GL_CXXALIASWARN (strsep);
 903 # if defined GNULIB_POSIXCHECK
 904 #  undef strsep
 905 _GL_WARN_ON_USE (strsep, "strsep cannot work correctly on character strings "
 906                  "in multibyte locales - "
 907                  "use mbssep if you care about internationalization");
 908 # endif
 909 #elif defined GNULIB_POSIXCHECK
 910 # undef strsep
 911 # if HAVE_RAW_DECL_STRSEP
 912 _GL_WARN_ON_USE (strsep, "strsep is unportable - "
 913                  "use gnulib module strsep for portability");
 914 # endif
 915 #endif
 916
 917 #if @GNULIB_STRSTR@
 918 # if @REPLACE_STRSTR@
 919 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 920 #   define strstr rpl_strstr
 921 #  endif
 922 _GL_FUNCDECL_RPL (strstr, char *, (const char *haystack, const char *needle),
 923                                   _GL_ATTRIBUTE_PURE
 924                                   _GL_ARG_NONNULL ((1, 2)));
 925 _GL_CXXALIAS_RPL (strstr, char *, (const char *haystack, const char *needle));
 926 # else
 927   /* On some systems, this function is defined as an overloaded function:
 928        extern "C++" { const char * strstr (const char *, const char *); }
 929        extern "C++" { char * strstr (char *, const char *); }  */
 930 _GL_CXXALIAS_SYS_CAST2 (strstr,
 931                         char *, (const char *haystack, const char *needle),
 932                         const char *, (const char *haystack, const char *needle));
 933 # endif
 934 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
 935      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4) \
 936          || defined __clang__)
 937 _GL_CXXALIASWARN1 (strstr, char *,
 938                    (char *haystack, const char *needle)
 939                    _GL_ATTRIBUTE_NOTHROW);
 940 _GL_CXXALIASWARN1 (strstr, const char *,
 941                    (const char *haystack, const char *needle)
 942                    _GL_ATTRIBUTE_NOTHROW);
 943 # elif __GLIBC__ >= 2
 944 _GL_CXXALIASWARN (strstr);
 945 # endif
 946 #elif defined GNULIB_POSIXCHECK
 947 /* strstr() does not work with multibyte strings if the locale encoding is
 948    different from UTF-8:
 949    POSIX says that it operates on "strings", and "string" in POSIX is defined
 950    as a sequence of bytes, not of characters.  */
 951 # undef strstr
 952 /* Assume strstr is always declared.  */
 953 _GL_WARN_ON_USE (strstr, "strstr is quadratic on many systems, and cannot "
 954                  "work correctly on character strings in most "
 955                  "multibyte locales - "
 956                  "use mbsstr if you care about internationalization, "
 957                  "or use strstr if you care about speed");
 958 #endif
 959
 960 /* Find the first occurrence of NEEDLE in HAYSTACK, using case-insensitive
 961    comparison.  */
 962 #if @GNULIB_STRCASESTR@
 963 # if @REPLACE_STRCASESTR@
 964 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 965 #   define strcasestr rpl_strcasestr
 966 #  endif
 967 _GL_FUNCDECL_RPL (strcasestr, char *,
 968                   (const char *haystack, const char *needle),
 969                   _GL_ATTRIBUTE_PURE
 970                   _GL_ARG_NONNULL ((1, 2)));
 971 _GL_CXXALIAS_RPL (strcasestr, char *,
 972                   (const char *haystack, const char *needle));
 973 # else
 974 #  if ! @HAVE_STRCASESTR@
 975 _GL_FUNCDECL_SYS (strcasestr, char *,
 976                   (const char *haystack, const char *needle),
 977                   _GL_ATTRIBUTE_PURE
 978                   _GL_ARG_NONNULL ((1, 2)));
 979 #  endif
 980   /* On some systems, this function is defined as an overloaded function:
 981        extern "C++" { const char * strcasestr (const char *, const char *); }
 982        extern "C++" { char * strcasestr (char *, const char *); }  */
 983 _GL_CXXALIAS_SYS_CAST2 (strcasestr,
 984                         char *, (const char *haystack, const char *needle),
 985                         const char *, (const char *haystack, const char *needle));
 986 # endif
 987 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
 988      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4) \
 989          || defined __clang__)
 990 _GL_CXXALIASWARN1 (strcasestr, char *,
 991                    (char *haystack, const char *needle)
 992                    _GL_ATTRIBUTE_NOTHROW);
 993 _GL_CXXALIASWARN1 (strcasestr, const char *,
 994                    (const char *haystack, const char *needle)
 995                    _GL_ATTRIBUTE_NOTHROW);
 996 # elif __GLIBC__ >= 2
 997 _GL_CXXALIASWARN (strcasestr);
 998 # endif
 999 #elif defined GNULIB_POSIXCHECK
1000 /* strcasestr() does not work with multibyte strings:
1001    It is a glibc extension, and glibc implements it only for unibyte
1002    locales.  */
1003 # undef strcasestr
1004 # if HAVE_RAW_DECL_STRCASESTR
1005 _GL_WARN_ON_USE (strcasestr, "strcasestr does work correctly on character "
1006                  "strings in multibyte locales - "
1007                  "use mbscasestr if you care about "
1008                  "internationalization, or use c-strcasestr if you want "
1009                  "a locale independent function");
1010 # endif
1011 #endif
1012
1013 /* Parse S into tokens separated by characters in DELIM.
1014    If S is NULL, the saved pointer in SAVE_PTR is used as
1015    the next starting point.  For example:
1016         char s[] = "-abc-=-def";
1017         char *sp;
1018         x = strtok_r(s, "-", &sp);      // x = "abc", sp = "=-def"
1019         x = strtok_r(NULL, "-=", &sp);  // x = "def", sp = NULL
1020         x = strtok_r(NULL, "=", &sp);   // x = NULL
1021                 // s = "abc\0-def\0"
1022
1023    This is a variant of strtok() that is multithread-safe.
1024
1025    For the POSIX documentation for this function, see:
1026    https://pubs.opengroup.org/onlinepubs/9699919799/functions/strtok.html
1027
1028    Caveat: It modifies the original string.
1029    Caveat: These functions cannot be used on constant strings.
1030    Caveat: The identity of the delimiting character is lost.
1031    Caveat: It doesn't work with multibyte strings unless all of the delimiter
1032            characters are ASCII characters < 0x30.
1033
1034    See also strsep().  */
1035 #if @GNULIB_STRTOK_R@
1036 # if @REPLACE_STRTOK_R@
1037 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1038 #   undef strtok_r
1039 #   define strtok_r rpl_strtok_r
1040 #  endif
1041 _GL_FUNCDECL_RPL (strtok_r, char *,
1042                   (char *restrict s, char const *restrict delim,
1043                    char **restrict save_ptr),
1044                   _GL_ARG_NONNULL ((2, 3)));
1045 _GL_CXXALIAS_RPL (strtok_r, char *,
1046                   (char *restrict s, char const *restrict delim,
1047                    char **restrict save_ptr));
1048 # else
1049 #  if @UNDEFINE_STRTOK_R@ || defined GNULIB_POSIXCHECK
1050 #   undef strtok_r
1051 #  endif
1052 #  if ! @HAVE_DECL_STRTOK_R@
1053 _GL_FUNCDECL_SYS (strtok_r, char *,
1054                   (char *restrict s, char const *restrict delim,
1055                    char **restrict save_ptr),
1056                   _GL_ARG_NONNULL ((2, 3)));
1057 #  endif
1058 _GL_CXXALIAS_SYS (strtok_r, char *,
1059                   (char *restrict s, char const *restrict delim,
1060                    char **restrict save_ptr));
1061 # endif
1062 _GL_CXXALIASWARN (strtok_r);
1063 # if defined GNULIB_POSIXCHECK
1064 _GL_WARN_ON_USE (strtok_r, "strtok_r cannot work correctly on character "
1065                  "strings in multibyte locales - "
1066                  "use mbstok_r if you care about internationalization");
1067 # endif
1068 #elif defined GNULIB_POSIXCHECK
1069 # undef strtok_r
1070 # if HAVE_RAW_DECL_STRTOK_R
1071 _GL_WARN_ON_USE (strtok_r, "strtok_r is unportable - "
1072                  "use gnulib module strtok_r for portability");
1073 # endif
1074 #endif
1075
1076
1077 /* The following functions are not specified by POSIX.  They are gnulib
1078    extensions.  */
1079
1080 #if @GNULIB_STR_STARTSWITH@
1081 /* Returns true if STRING starts with PREFIX.
1082    Returns false otherwise.  */
1083 _GL_EXTERN_C bool str_startswith (const char *string, const char *prefix)
1084      _GL_ATTRIBUTE_PURE
1085      _GL_ARG_NONNULL ((1, 2));
1086 #endif
1087
1088 #if @GNULIB_STR_ENDSWITH@
1089 /* Returns true if STRING ends with SUFFIX.
1090    Returns false otherwise.  */
1091 _GL_EXTERN_C bool str_endswith (const char *string, const char *prefix)
1092      _GL_ATTRIBUTE_PURE
1093      _GL_ARG_NONNULL ((1, 2));
1094 #endif
1095
1096 #if @GNULIB_MBSLEN@
1097 /* Return the number of multibyte characters in the character string STRING.
1098    This considers multibyte characters, unlike strlen, which counts bytes.  */
1099 # ifdef __MirBSD__  /* MirBSD defines mbslen as a macro.  Override it.  */
1100 #  undef mbslen
1101 # endif
1102 # if @HAVE_MBSLEN@  /* AIX, OSF/1, MirBSD define mbslen already in libc.  */
1103 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1104 #   define mbslen rpl_mbslen
1105 #  endif
1106 _GL_FUNCDECL_RPL (mbslen, size_t, (const char *string),
1107                                   _GL_ATTRIBUTE_PURE
1108                                   _GL_ARG_NONNULL ((1)));
1109 _GL_CXXALIAS_RPL (mbslen, size_t, (const char *string));
1110 # else
1111 _GL_FUNCDECL_SYS (mbslen, size_t, (const char *string),
1112                                   _GL_ATTRIBUTE_PURE
1113                                   _GL_ARG_NONNULL ((1)));
1114 _GL_CXXALIAS_SYS (mbslen, size_t, (const char *string));
1115 # endif
1116 # if __GLIBC__ >= 2
1117 _GL_CXXALIASWARN (mbslen);
1118 # endif
1119 #endif
1120
1121 #if @GNULIB_MBSNLEN@
1122 /* Return the number of multibyte characters in the character string starting
1123    at STRING and ending at STRING + LEN.  */
1124 _GL_EXTERN_C size_t mbsnlen (const char *string, size_t len)
1125      _GL_ATTRIBUTE_PURE
1126      _GL_ARG_NONNULL ((1));
1127 #endif
1128
1129 #if @GNULIB_MBSCHR@
1130 /* Locate the first single-byte character C in the character string STRING,
1131    and return a pointer to it.  Return NULL if C is not found in STRING.
1132    Unlike strchr(), this function works correctly in multibyte locales with
1133    encodings such as GB18030.  */
1134 # if defined __hpux
1135 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1136 #   define mbschr rpl_mbschr /* avoid collision with HP-UX function */
1137 #  endif
1138 _GL_FUNCDECL_RPL (mbschr, char *, (const char *string, int c),
1139                                   _GL_ATTRIBUTE_PURE
1140                                   _GL_ARG_NONNULL ((1)));
1141 _GL_CXXALIAS_RPL (mbschr, char *, (const char *string, int c));
1142 # else
1143 _GL_FUNCDECL_SYS (mbschr, char *, (const char *string, int c),
1144                                   _GL_ATTRIBUTE_PURE
1145                                   _GL_ARG_NONNULL ((1)));
1146 _GL_CXXALIAS_SYS (mbschr, char *, (const char *string, int c));
1147 # endif
1148 _GL_CXXALIASWARN (mbschr);
1149 #endif
1150
1151 #if @GNULIB_MBSRCHR@
1152 /* Locate the last single-byte character C in the character string STRING,
1153    and return a pointer to it.  Return NULL if C is not found in STRING.
1154    Unlike strrchr(), this function works correctly in multibyte locales with
1155    encodings such as GB18030.  */
1156 # if defined __hpux || defined __INTERIX
1157 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1158 #   define mbsrchr rpl_mbsrchr /* avoid collision with system function */
1159 #  endif
1160 _GL_FUNCDECL_RPL (mbsrchr, char *, (const char *string, int c),
1161                                    _GL_ATTRIBUTE_PURE
1162                                    _GL_ARG_NONNULL ((1)));
1163 _GL_CXXALIAS_RPL (mbsrchr, char *, (const char *string, int c));
1164 # else
1165 _GL_FUNCDECL_SYS (mbsrchr, char *, (const char *string, int c),
1166                                    _GL_ATTRIBUTE_PURE
1167                                    _GL_ARG_NONNULL ((1)));
1168 _GL_CXXALIAS_SYS (mbsrchr, char *, (const char *string, int c));
1169 # endif
1170 _GL_CXXALIASWARN (mbsrchr);
1171 #endif
1172
1173 #if @GNULIB_MBSSTR@
1174 /* Find the first occurrence of the character string NEEDLE in the character
1175    string HAYSTACK.  Return NULL if NEEDLE is not found in HAYSTACK.
1176    Unlike strstr(), this function works correctly in multibyte locales with
1177    encodings different from UTF-8.  */
1178 _GL_EXTERN_C char * mbsstr (const char *haystack, const char *needle)
1179      _GL_ATTRIBUTE_PURE
1180      _GL_ARG_NONNULL ((1, 2));
1181 #endif
1182
1183 #if @GNULIB_MBSCASECMP@
1184 /* Compare the character strings S1 and S2, ignoring case, returning less than,
1185    equal to or greater than zero if S1 is lexicographically less than, equal to
1186    or greater than S2.
1187    Note: This function may, in multibyte locales, return 0 for strings of
1188    different lengths!
1189    Unlike strcasecmp(), this function works correctly in multibyte locales.  */
1190 _GL_EXTERN_C int mbscasecmp (const char *s1, const char *s2)
1191      _GL_ATTRIBUTE_PURE
1192      _GL_ARG_NONNULL ((1, 2));
1193 #endif
1194
1195 #if @GNULIB_MBSNCASECMP@
1196 /* Compare the initial segment of the character string S1 consisting of at most
1197    N characters with the initial segment of the character string S2 consisting
1198    of at most N characters, ignoring case, returning less than, equal to or
1199    greater than zero if the initial segment of S1 is lexicographically less
1200    than, equal to or greater than the initial segment of S2.
1201    Note: This function may, in multibyte locales, return 0 for initial segments
1202    of different lengths!
1203    Unlike strncasecmp(), this function works correctly in multibyte locales.
1204    But beware that N is not a byte count but a character count!  */
1205 _GL_EXTERN_C int mbsncasecmp (const char *s1, const char *s2, size_t n)
1206      _GL_ATTRIBUTE_PURE
1207      _GL_ARG_NONNULL ((1, 2));
1208 #endif
1209
1210 #if @GNULIB_MBSPCASECMP@
1211 /* Compare the initial segment of the character string STRING consisting of
1212    at most mbslen (PREFIX) characters with the character string PREFIX,
1213    ignoring case.  If the two match, return a pointer to the first byte
1214    after this prefix in STRING.  Otherwise, return NULL.
1215    Note: This function may, in multibyte locales, return non-NULL if STRING
1216    is of smaller length than PREFIX!
1217    Unlike strncasecmp(), this function works correctly in multibyte
1218    locales.  */
1219 _GL_EXTERN_C char * mbspcasecmp (const char *string, const char *prefix)
1220      _GL_ATTRIBUTE_PURE
1221      _GL_ARG_NONNULL ((1, 2));
1222 #endif
1223
1224 #if @GNULIB_MBSCASESTR@
1225 /* Find the first occurrence of the character string NEEDLE in the character
1226    string HAYSTACK, using case-insensitive comparison.
1227    Note: This function may, in multibyte locales, return success even if
1228    strlen (haystack) < strlen (needle) !
1229    Unlike strcasestr(), this function works correctly in multibyte locales.  */
1230 _GL_EXTERN_C char * mbscasestr (const char *haystack, const char *needle)
1231      _GL_ATTRIBUTE_PURE
1232      _GL_ARG_NONNULL ((1, 2));
1233 #endif
1234
1235 #if @GNULIB_MBSCSPN@
1236 /* Find the first occurrence in the character string STRING of any character
1237    in the character string ACCEPT.  Return the number of bytes from the
1238    beginning of the string to this occurrence, or to the end of the string
1239    if none exists.
1240    Unlike strcspn(), this function works correctly in multibyte locales.  */
1241 _GL_EXTERN_C size_t mbscspn (const char *string, const char *accept)
1242      _GL_ATTRIBUTE_PURE
1243      _GL_ARG_NONNULL ((1, 2));
1244 #endif
1245
1246 #if @GNULIB_MBSPBRK@
1247 /* Find the first occurrence in the character string STRING of any character
1248    in the character string ACCEPT.  Return the pointer to it, or NULL if none
1249    exists.
1250    Unlike strpbrk(), this function works correctly in multibyte locales.  */
1251 # if defined __hpux
1252 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1253 #   define mbspbrk rpl_mbspbrk /* avoid collision with HP-UX function */
1254 #  endif
1255 _GL_FUNCDECL_RPL (mbspbrk, char *, (const char *string, const char *accept),
1256                                    _GL_ATTRIBUTE_PURE
1257                                    _GL_ARG_NONNULL ((1, 2)));
1258 _GL_CXXALIAS_RPL (mbspbrk, char *, (const char *string, const char *accept));
1259 # else
1260 _GL_FUNCDECL_SYS (mbspbrk, char *, (const char *string, const char *accept),
1261                                    _GL_ATTRIBUTE_PURE
1262                                    _GL_ARG_NONNULL ((1, 2)));
1263 _GL_CXXALIAS_SYS (mbspbrk, char *, (const char *string, const char *accept));
1264 # endif
1265 _GL_CXXALIASWARN (mbspbrk);
1266 #endif
1267
1268 #if @GNULIB_MBSSPN@
1269 /* Find the first occurrence in the character string STRING of any character
1270    not in the character string REJECT.  Return the number of bytes from the
1271    beginning of the string to this occurrence, or to the end of the string
1272    if none exists.
1273    Unlike strspn(), this function works correctly in multibyte locales.  */
1274 _GL_EXTERN_C size_t mbsspn (const char *string, const char *reject)
1275      _GL_ATTRIBUTE_PURE
1276      _GL_ARG_NONNULL ((1, 2));
1277 #endif
1278
1279 #if @GNULIB_MBSSEP@
1280 /* Search the next delimiter (multibyte character listed in the character
1281    string DELIM) starting at the character string *STRINGP.
1282    If one is found, overwrite it with a NUL, and advance *STRINGP to point
1283    to the next multibyte character after it.  Otherwise, set *STRINGP to NULL.
1284    If *STRINGP was already NULL, nothing happens.
1285    Return the old value of *STRINGP.
1286
1287    This is a variant of mbstok_r() that supports empty fields.
1288
1289    Caveat: It modifies the original string.
1290    Caveat: These functions cannot be used on constant strings.
1291    Caveat: The identity of the delimiting character is lost.
1292
1293    See also mbstok_r().  */
1294 _GL_EXTERN_C char * mbssep (char **stringp, const char *delim)
1295      _GL_ARG_NONNULL ((1, 2));
1296 #endif
1297
1298 #if @GNULIB_MBSTOK_R@
1299 /* Parse the character string STRING into tokens separated by characters in
1300    the character string DELIM.
1301    If STRING is NULL, the saved pointer in SAVE_PTR is used as
1302    the next starting point.  For example:
1303         char s[] = "-abc-=-def";
1304         char *sp;
1305         x = mbstok_r(s, "-", &sp);      // x = "abc", sp = "=-def"
1306         x = mbstok_r(NULL, "-=", &sp);  // x = "def", sp = NULL
1307         x = mbstok_r(NULL, "=", &sp);   // x = NULL
1308                 // s = "abc\0-def\0"
1309
1310    Caveat: It modifies the original string.
1311    Caveat: These functions cannot be used on constant strings.
1312    Caveat: The identity of the delimiting character is lost.
1313
1314    See also mbssep().  */
1315 _GL_EXTERN_C char * mbstok_r (char *restrict string, const char *delim,
1316                               char **save_ptr)
1317      _GL_ARG_NONNULL ((2, 3));
1318 #endif
1319
1320 #if @GNULIB_MBS_STARTSWITH@
1321 /* Returns true if STRING starts with PREFIX.
1322    Returns false otherwise.  */
1323 _GL_EXTERN_C bool mbs_startswith (const char *string, const char *prefix)
1324      _GL_ATTRIBUTE_PURE
1325      _GL_ARG_NONNULL ((1, 2));
1326 /* No extra code is needed for multibyte locales for this function.  */
1327 # define mbs_startswith str_startswith
1328 #endif
1329
1330 #if @GNULIB_MBS_ENDSWITH@
1331 /* Returns true if STRING ends with SUFFIX.
1332    Returns false otherwise.
1333    Unlike str_endswith(), this function works correctly in multibyte locales.
1334  */
1335 _GL_EXTERN_C bool mbs_endswith (const char *string, const char *suffix)
1336      _GL_ATTRIBUTE_PURE
1337      _GL_ARG_NONNULL ((1, 2));
1338 #endif
1339
1340 /* Map any int, typically from errno, into an error message.  */
1341 #if @GNULIB_STRERROR@
1342 # if @REPLACE_STRERROR@
1343 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1344 #   undef strerror
1345 #   define strerror rpl_strerror
1346 #  endif
1347 _GL_FUNCDECL_RPL (strerror, char *, (int), );
1348 _GL_CXXALIAS_RPL (strerror, char *, (int));
1349 # else
1350 _GL_CXXALIAS_SYS (strerror, char *, (int));
1351 # endif
1352 # if __GLIBC__ >= 2
1353 _GL_CXXALIASWARN (strerror);
1354 # endif
1355 #elif defined GNULIB_POSIXCHECK
1356 # undef strerror
1357 /* Assume strerror is always declared.  */
1358 _GL_WARN_ON_USE (strerror, "strerror is unportable - "
1359                  "use gnulib module strerror to guarantee non-NULL result");
1360 #endif
1361
1362 /* Map any int, typically from errno, into an error message.  Multithread-safe.
1363    Uses the POSIX declaration, not the glibc declaration.  */
1364 #if @GNULIB_STRERROR_R@
1365 # if @REPLACE_STRERROR_R@
1366 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1367 #   undef strerror_r
1368 #   define strerror_r rpl_strerror_r
1369 #  endif
1370 _GL_FUNCDECL_RPL (strerror_r, int, (int errnum, char *buf, size_t buflen),
1371                                    _GL_ARG_NONNULL ((2)));
1372 _GL_CXXALIAS_RPL (strerror_r, int, (int errnum, char *buf, size_t buflen));
1373 # else
1374 #  if !@HAVE_DECL_STRERROR_R@
1375 _GL_FUNCDECL_SYS (strerror_r, int, (int errnum, char *buf, size_t buflen),
1376                                    _GL_ARG_NONNULL ((2)));
1377 #  endif
1378 _GL_CXXALIAS_SYS (strerror_r, int, (int errnum, char *buf, size_t buflen));
1379 # endif
1380 # if __GLIBC__ >= 2 && @HAVE_DECL_STRERROR_R@
1381 _GL_CXXALIASWARN (strerror_r);
1382 # endif
1383 #elif defined GNULIB_POSIXCHECK
1384 # undef strerror_r
1385 # if HAVE_RAW_DECL_STRERROR_R
1386 _GL_WARN_ON_USE (strerror_r, "strerror_r is unportable - "
1387                  "use gnulib module strerror_r-posix for portability");
1388 # endif
1389 #endif
1390
1391 /* Return the name of the system error code ERRNUM.  */
1392 #if @GNULIB_STRERRORNAME_NP@
1393 # if @REPLACE_STRERRORNAME_NP@
1394 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1395 #   undef strerrorname_np
1396 #   define strerrorname_np rpl_strerrorname_np
1397 #  endif
1398 _GL_FUNCDECL_RPL (strerrorname_np, const char *, (int errnum), );
1399 _GL_CXXALIAS_RPL (strerrorname_np, const char *, (int errnum));
1400 # else
1401 #  if !@HAVE_STRERRORNAME_NP@
1402 _GL_FUNCDECL_SYS (strerrorname_np, const char *, (int errnum), );
1403 #  endif
1404 _GL_CXXALIAS_SYS (strerrorname_np, const char *, (int errnum));
1405 # endif
1406 _GL_CXXALIASWARN (strerrorname_np);
1407 #elif defined GNULIB_POSIXCHECK
1408 # undef strerrorname_np
1409 # if HAVE_RAW_DECL_STRERRORNAME_NP
1410 _GL_WARN_ON_USE (strerrorname_np, "strerrorname_np is unportable - "
1411                  "use gnulib module strerrorname_np for portability");
1412 # endif
1413 #endif
1414
1415 /* Return an abbreviation string for the signal number SIG.  */
1416 #if @GNULIB_SIGABBREV_NP@
1417 # if ! @HAVE_SIGABBREV_NP@
1418 _GL_FUNCDECL_SYS (sigabbrev_np, const char *, (int sig), );
1419 # endif
1420 _GL_CXXALIAS_SYS (sigabbrev_np, const char *, (int sig));
1421 _GL_CXXALIASWARN (sigabbrev_np);
1422 #elif defined GNULIB_POSIXCHECK
1423 # undef sigabbrev_np
1424 # if HAVE_RAW_DECL_SIGABBREV_NP
1425 _GL_WARN_ON_USE (sigabbrev_np, "sigabbrev_np is unportable - "
1426                  "use gnulib module sigabbrev_np for portability");
1427 # endif
1428 #endif
1429
1430 /* Return an English description string for the signal number SIG.  */
1431 #if @GNULIB_SIGDESCR_NP@
1432 # if ! @HAVE_SIGDESCR_NP@
1433 _GL_FUNCDECL_SYS (sigdescr_np, const char *, (int sig), );
1434 # endif
1435 _GL_CXXALIAS_SYS (sigdescr_np, const char *, (int sig));
1436 _GL_CXXALIASWARN (sigdescr_np);
1437 #elif defined GNULIB_POSIXCHECK
1438 # undef sigdescr_np
1439 # if HAVE_RAW_DECL_SIGDESCR_NP
1440 _GL_WARN_ON_USE (sigdescr_np, "sigdescr_np is unportable - "
1441                  "use gnulib module sigdescr_np for portability");
1442 # endif
1443 #endif
1444
1445 #if @GNULIB_STRSIGNAL@
1446 # if @REPLACE_STRSIGNAL@
1447 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1448 #   define strsignal rpl_strsignal
1449 #  endif
1450 _GL_FUNCDECL_RPL (strsignal, char *, (int __sig), );
1451 _GL_CXXALIAS_RPL (strsignal, char *, (int __sig));
1452 # else
1453 #  if ! @HAVE_DECL_STRSIGNAL@
1454 _GL_FUNCDECL_SYS (strsignal, char *, (int __sig), );
1455 #  endif
1456 /* Need to cast, because on Cygwin 1.5.x systems, the return type is
1457    'const char *'.  */
1458 _GL_CXXALIAS_SYS_CAST (strsignal, char *, (int __sig));
1459 # endif
1460 _GL_CXXALIASWARN (strsignal);
1461 #elif defined GNULIB_POSIXCHECK
1462 # undef strsignal
1463 # if HAVE_RAW_DECL_STRSIGNAL
1464 _GL_WARN_ON_USE (strsignal, "strsignal is unportable - "
1465                  "use gnulib module strsignal for portability");
1466 # endif
1467 #endif
1468
1469 #if @GNULIB_STRVERSCMP@
1470 # if @REPLACE_STRVERSCMP@
1471 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
1472 #   define strverscmp rpl_strverscmp
1473 #  endif
1474 _GL_FUNCDECL_RPL (strverscmp, int, (const char *, const char *),
1475                                    _GL_ATTRIBUTE_PURE
1476                                    _GL_ARG_NONNULL ((1, 2)));
1477 _GL_CXXALIAS_RPL (strverscmp, int, (const char *, const char *));
1478 # else
1479 #  if !@HAVE_STRVERSCMP@
1480 _GL_FUNCDECL_SYS (strverscmp, int, (const char *, const char *),
1481                                    _GL_ATTRIBUTE_PURE
1482                                    _GL_ARG_NONNULL ((1, 2)));
1483 #  endif
1484 _GL_CXXALIAS_SYS (strverscmp, int, (const char *, const char *));
1485 # endif
1486 _GL_CXXALIASWARN (strverscmp);
1487 #elif defined GNULIB_POSIXCHECK
1488 # undef strverscmp
1489 # if HAVE_RAW_DECL_STRVERSCMP
1490 _GL_WARN_ON_USE (strverscmp, "strverscmp is unportable - "
1491                  "use gnulib module strverscmp for portability");
1492 # endif
1493 #endif
1494
1495
1496 #endif /* _@GUARD_PREFIX@_STRING_H */
1497 #endif /* _@GUARD_PREFIX@_STRING_H */
1498 #endif