lib/string.in.h

   1 /* A GNU-like <string.h>.
   2
   3    Copyright (C) 1995-1996, 2001-2014 Free Software Foundation, Inc.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3, or (at your option)
   8    any later version.
   9
  10    This program 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 General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, see <http://www.gnu.org/licenses/>.  */
  17
  18 #ifndef _@GUARD_PREFIX@_STRING_H
  19
  20 #if __GNUC__ >= 3
  21 @PRAGMA_SYSTEM_HEADER@
  22 #endif
  23 @PRAGMA_COLUMNS@
  24
  25 /* The include_next requires a split double-inclusion guard.  */
  26 #@INCLUDE_NEXT@ @NEXT_STRING_H@
  27
  28 #ifndef _@GUARD_PREFIX@_STRING_H
  29 #define _@GUARD_PREFIX@_STRING_H
  30
  31 /* NetBSD 5.0 mis-defines NULL.  */
  32 #include <stddef.h>
  33
  34 /* MirBSD defines mbslen as a macro.  */
  35 #if @GNULIB_MBSLEN@ && defined __MirBSD__
  36 # include <wchar.h>
  37 #endif
  38
  39 /* The __attribute__ feature is available in gcc versions 2.5 and later.
  40    The attribute __pure__ was added in gcc 2.96.  */
  41 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
  42 # define _GL_ATTRIBUTE_PURE __attribute__ ((__pure__))
  43 #else
  44 # define _GL_ATTRIBUTE_PURE /* empty */
  45 #endif
  46
  47 /* NetBSD 5.0 declares strsignal in <unistd.h>, not in <string.h>.  */
  48 /* But in any case avoid namespace pollution on glibc systems.  */
  49 #if (@GNULIB_STRSIGNAL@ || defined GNULIB_POSIXCHECK) && defined __NetBSD__ \
  50     && ! defined __GLIBC__
  51 # include <unistd.h>
  52 #endif
  53
  54 /* The definitions of _GL_FUNCDECL_RPL etc. are copied here.  */
  55
  56 /* The definition of _GL_ARG_NONNULL is copied here.  */
  57
  58 /* The definition of _GL_WARN_ON_USE is copied here.  */
  59
  60
  61 /* Find the index of the least-significant set bit.  */
  62 #if @GNULIB_FFSL@
  63 # if !@HAVE_FFSL@
  64 _GL_FUNCDECL_SYS (ffsl, int, (long int i));
  65 # endif
  66 _GL_CXXALIAS_SYS (ffsl, int, (long int i));
  67 _GL_CXXALIASWARN (ffsl);
  68 #elif defined GNULIB_POSIXCHECK
  69 # undef ffsl
  70 # if HAVE_RAW_DECL_FFSL
  71 _GL_WARN_ON_USE (ffsl, "ffsl is not portable - use the ffsl module");
  72 # endif
  73 #endif
  74
  75
  76 /* Find the index of the least-significant set bit.  */
  77 #if @GNULIB_FFSLL@
  78 # if !@HAVE_FFSLL@
  79 _GL_FUNCDECL_SYS (ffsll, int, (long long int i));
  80 # endif
  81 _GL_CXXALIAS_SYS (ffsll, int, (long long int i));
  82 _GL_CXXALIASWARN (ffsll);
  83 #elif defined GNULIB_POSIXCHECK
  84 # undef ffsll
  85 # if HAVE_RAW_DECL_FFSLL
  86 _GL_WARN_ON_USE (ffsll, "ffsll is not portable - use the ffsll module");
  87 # endif
  88 #endif
  89
  90
  91 /* Return the first instance of C within N bytes of S, or NULL.  */
  92 #if @GNULIB_MEMCHR@
  93 # if @REPLACE_MEMCHR@
  94 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
  95 #   define memchr rpl_memchr
  96 #  endif
  97 _GL_FUNCDECL_RPL (memchr, void *, (void const *__s, int __c, size_t __n)
  98                                   _GL_ATTRIBUTE_PURE
  99                                   _GL_ARG_NONNULL ((1)));
 100 _GL_CXXALIAS_RPL (memchr, void *, (void const *__s, int __c, size_t __n));
 101 # else
 102 #  if ! @HAVE_MEMCHR@
 103 _GL_FUNCDECL_SYS (memchr, void *, (void const *__s, int __c, size_t __n)
 104                                   _GL_ATTRIBUTE_PURE
 105                                   _GL_ARG_NONNULL ((1)));
 106 #  endif
 107   /* On some systems, this function is defined as an overloaded function:
 108        extern "C" { const void * std::memchr (const void *, int, size_t); }
 109        extern "C++" { void * std::memchr (void *, int, size_t); }  */
 110 _GL_CXXALIAS_SYS_CAST2 (memchr,
 111                         void *, (void const *__s, int __c, size_t __n),
 112                         void const *, (void const *__s, int __c, size_t __n));
 113 # endif
 114 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
 115      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
 116 _GL_CXXALIASWARN1 (memchr, void *, (void *__s, int __c, size_t __n));
 117 _GL_CXXALIASWARN1 (memchr, void const *,
 118                    (void const *__s, int __c, size_t __n));
 119 # else
 120 _GL_CXXALIASWARN (memchr);
 121 # endif
 122 #elif defined GNULIB_POSIXCHECK
 123 # undef memchr
 124 /* Assume memchr is always declared.  */
 125 _GL_WARN_ON_USE (memchr, "memchr has platform-specific bugs - "
 126                  "use gnulib module memchr for portability" );
 127 #endif
 128
 129 /* Return the first occurrence of NEEDLE in HAYSTACK.  */
 130 #if @GNULIB_MEMMEM@
 131 # if @REPLACE_MEMMEM@
 132 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 133 #   define memmem rpl_memmem
 134 #  endif
 135 _GL_FUNCDECL_RPL (memmem, void *,
 136                   (void const *__haystack, size_t __haystack_len,
 137                    void const *__needle, size_t __needle_len)
 138                   _GL_ATTRIBUTE_PURE
 139                   _GL_ARG_NONNULL ((1, 3)));
 140 _GL_CXXALIAS_RPL (memmem, void *,
 141                   (void const *__haystack, size_t __haystack_len,
 142                    void const *__needle, size_t __needle_len));
 143 # else
 144 #  if ! @HAVE_DECL_MEMMEM@
 145 _GL_FUNCDECL_SYS (memmem, void *,
 146                   (void const *__haystack, size_t __haystack_len,
 147                    void const *__needle, size_t __needle_len)
 148                   _GL_ATTRIBUTE_PURE
 149                   _GL_ARG_NONNULL ((1, 3)));
 150 #  endif
 151 _GL_CXXALIAS_SYS (memmem, void *,
 152                   (void const *__haystack, size_t __haystack_len,
 153                    void const *__needle, size_t __needle_len));
 154 # endif
 155 _GL_CXXALIASWARN (memmem);
 156 #elif defined GNULIB_POSIXCHECK
 157 # undef memmem
 158 # if HAVE_RAW_DECL_MEMMEM
 159 _GL_WARN_ON_USE (memmem, "memmem is unportable and often quadratic - "
 160                  "use gnulib module memmem-simple for portability, "
 161                  "and module memmem for speed" );
 162 # endif
 163 #endif
 164
 165 /* Copy N bytes of SRC to DEST, return pointer to bytes after the
 166    last written byte.  */
 167 #if @GNULIB_MEMPCPY@
 168 # if ! @HAVE_MEMPCPY@
 169 _GL_FUNCDECL_SYS (mempcpy, void *,
 170                   (void *restrict __dest, void const *restrict __src,
 171                    size_t __n)
 172                   _GL_ARG_NONNULL ((1, 2)));
 173 # endif
 174 _GL_CXXALIAS_SYS (mempcpy, void *,
 175                   (void *restrict __dest, void const *restrict __src,
 176                    size_t __n));
 177 _GL_CXXALIASWARN (mempcpy);
 178 #elif defined GNULIB_POSIXCHECK
 179 # undef mempcpy
 180 # if HAVE_RAW_DECL_MEMPCPY
 181 _GL_WARN_ON_USE (mempcpy, "mempcpy is unportable - "
 182                  "use gnulib module mempcpy for portability");
 183 # endif
 184 #endif
 185
 186 /* Search backwards through a block for a byte (specified as an int).  */
 187 #if @GNULIB_MEMRCHR@
 188 # if ! @HAVE_DECL_MEMRCHR@
 189 _GL_FUNCDECL_SYS (memrchr, void *, (void const *, int, size_t)
 190                                    _GL_ATTRIBUTE_PURE
 191                                    _GL_ARG_NONNULL ((1)));
 192 # endif
 193   /* On some systems, this function is defined as an overloaded function:
 194        extern "C++" { const void * std::memrchr (const void *, int, size_t); }
 195        extern "C++" { void * std::memrchr (void *, int, size_t); }  */
 196 _GL_CXXALIAS_SYS_CAST2 (memrchr,
 197                         void *, (void const *, int, size_t),
 198                         void const *, (void const *, int, size_t));
 199 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
 200      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
 201 _GL_CXXALIASWARN1 (memrchr, void *, (void *, int, size_t));
 202 _GL_CXXALIASWARN1 (memrchr, void const *, (void const *, int, size_t));
 203 # else
 204 _GL_CXXALIASWARN (memrchr);
 205 # endif
 206 #elif defined GNULIB_POSIXCHECK
 207 # undef memrchr
 208 # if HAVE_RAW_DECL_MEMRCHR
 209 _GL_WARN_ON_USE (memrchr, "memrchr is unportable - "
 210                  "use gnulib module memrchr for portability");
 211 # endif
 212 #endif
 213
 214 /* Find the first occurrence of C in S.  More efficient than
 215    memchr(S,C,N), at the expense of undefined behavior if C does not
 216    occur within N bytes.  */
 217 #if @GNULIB_RAWMEMCHR@
 218 # if ! @HAVE_RAWMEMCHR@
 219 _GL_FUNCDECL_SYS (rawmemchr, void *, (void const *__s, int __c_in)
 220                                      _GL_ATTRIBUTE_PURE
 221                                      _GL_ARG_NONNULL ((1)));
 222 # endif
 223   /* On some systems, this function is defined as an overloaded function:
 224        extern "C++" { const void * std::rawmemchr (const void *, int); }
 225        extern "C++" { void * std::rawmemchr (void *, int); }  */
 226 _GL_CXXALIAS_SYS_CAST2 (rawmemchr,
 227                         void *, (void const *__s, int __c_in),
 228                         void const *, (void const *__s, int __c_in));
 229 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
 230      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
 231 _GL_CXXALIASWARN1 (rawmemchr, void *, (void *__s, int __c_in));
 232 _GL_CXXALIASWARN1 (rawmemchr, void const *, (void const *__s, int __c_in));
 233 # else
 234 _GL_CXXALIASWARN (rawmemchr);
 235 # endif
 236 #elif defined GNULIB_POSIXCHECK
 237 # undef rawmemchr
 238 # if HAVE_RAW_DECL_RAWMEMCHR
 239 _GL_WARN_ON_USE (rawmemchr, "rawmemchr is unportable - "
 240                  "use gnulib module rawmemchr for portability");
 241 # endif
 242 #endif
 243
 244 /* Copy SRC to DST, returning the address of the terminating '\0' in DST.  */
 245 #if @GNULIB_STPCPY@
 246 # if ! @HAVE_STPCPY@
 247 _GL_FUNCDECL_SYS (stpcpy, char *,
 248                   (char *restrict __dst, char const *restrict __src)
 249                   _GL_ARG_NONNULL ((1, 2)));
 250 # endif
 251 _GL_CXXALIAS_SYS (stpcpy, char *,
 252                   (char *restrict __dst, char const *restrict __src));
 253 _GL_CXXALIASWARN (stpcpy);
 254 #elif defined GNULIB_POSIXCHECK
 255 # undef stpcpy
 256 # if HAVE_RAW_DECL_STPCPY
 257 _GL_WARN_ON_USE (stpcpy, "stpcpy is unportable - "
 258                  "use gnulib module stpcpy for portability");
 259 # endif
 260 #endif
 261
 262 /* Copy no more than N bytes of SRC to DST, returning a pointer past the
 263    last non-NUL byte written into DST.  */
 264 #if @GNULIB_STPNCPY@
 265 # if @REPLACE_STPNCPY@
 266 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 267 #   undef stpncpy
 268 #   define stpncpy rpl_stpncpy
 269 #  endif
 270 _GL_FUNCDECL_RPL (stpncpy, char *,
 271                   (char *restrict __dst, char const *restrict __src,
 272                    size_t __n)
 273                   _GL_ARG_NONNULL ((1, 2)));
 274 _GL_CXXALIAS_RPL (stpncpy, char *,
 275                   (char *restrict __dst, char const *restrict __src,
 276                    size_t __n));
 277 # else
 278 #  if ! @HAVE_STPNCPY@
 279 _GL_FUNCDECL_SYS (stpncpy, char *,
 280                   (char *restrict __dst, char const *restrict __src,
 281                    size_t __n)
 282                   _GL_ARG_NONNULL ((1, 2)));
 283 #  endif
 284 _GL_CXXALIAS_SYS (stpncpy, char *,
 285                   (char *restrict __dst, char const *restrict __src,
 286                    size_t __n));
 287 # endif
 288 _GL_CXXALIASWARN (stpncpy);
 289 #elif defined GNULIB_POSIXCHECK
 290 # undef stpncpy
 291 # if HAVE_RAW_DECL_STPNCPY
 292 _GL_WARN_ON_USE (stpncpy, "stpncpy is unportable - "
 293                  "use gnulib module stpncpy for portability");
 294 # endif
 295 #endif
 296
 297 #if defined GNULIB_POSIXCHECK
 298 /* strchr() does not work with multibyte strings if the locale encoding is
 299    GB18030 and the character to be searched is a digit.  */
 300 # undef strchr
 301 /* Assume strchr is always declared.  */
 302 _GL_WARN_ON_USE (strchr, "strchr cannot work correctly on character strings "
 303                  "in some multibyte locales - "
 304                  "use mbschr if you care about internationalization");
 305 #endif
 306
 307 /* Find the first occurrence of C in S or the final NUL byte.  */
 308 #if @GNULIB_STRCHRNUL@
 309 # if @REPLACE_STRCHRNUL@
 310 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 311 #   define strchrnul rpl_strchrnul
 312 #  endif
 313 _GL_FUNCDECL_RPL (strchrnul, char *, (const char *__s, int __c_in)
 314                                      _GL_ATTRIBUTE_PURE
 315                                      _GL_ARG_NONNULL ((1)));
 316 _GL_CXXALIAS_RPL (strchrnul, char *,
 317                   (const char *str, int ch));
 318 # else
 319 #  if ! @HAVE_STRCHRNUL@
 320 _GL_FUNCDECL_SYS (strchrnul, char *, (char const *__s, int __c_in)
 321                                      _GL_ATTRIBUTE_PURE
 322                                      _GL_ARG_NONNULL ((1)));
 323 #  endif
 324   /* On some systems, this function is defined as an overloaded function:
 325        extern "C++" { const char * std::strchrnul (const char *, int); }
 326        extern "C++" { char * std::strchrnul (char *, int); }  */
 327 _GL_CXXALIAS_SYS_CAST2 (strchrnul,
 328                         char *, (char const *__s, int __c_in),
 329                         char const *, (char const *__s, int __c_in));
 330 # endif
 331 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
 332      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
 333 _GL_CXXALIASWARN1 (strchrnul, char *, (char *__s, int __c_in));
 334 _GL_CXXALIASWARN1 (strchrnul, char const *, (char const *__s, int __c_in));
 335 # else
 336 _GL_CXXALIASWARN (strchrnul);
 337 # endif
 338 #elif defined GNULIB_POSIXCHECK
 339 # undef strchrnul
 340 # if HAVE_RAW_DECL_STRCHRNUL
 341 _GL_WARN_ON_USE (strchrnul, "strchrnul is unportable - "
 342                  "use gnulib module strchrnul for portability");
 343 # endif
 344 #endif
 345
 346 /* Duplicate S, returning an identical malloc'd string.  */
 347 #if @GNULIB_STRDUP@
 348 # if @REPLACE_STRDUP@
 349 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 350 #   undef strdup
 351 #   define strdup rpl_strdup
 352 #  endif
 353 _GL_FUNCDECL_RPL (strdup, char *, (char const *__s) _GL_ARG_NONNULL ((1)));
 354 _GL_CXXALIAS_RPL (strdup, char *, (char const *__s));
 355 # else
 356 #  if defined __cplusplus && defined GNULIB_NAMESPACE && defined strdup
 357     /* strdup exists as a function and as a macro.  Get rid of the macro.  */
 358 #   undef strdup
 359 #  endif
 360 #  if !(@HAVE_DECL_STRDUP@ || defined strdup)
 361 _GL_FUNCDECL_SYS (strdup, char *, (char const *__s) _GL_ARG_NONNULL ((1)));
 362 #  endif
 363 _GL_CXXALIAS_SYS (strdup, char *, (char const *__s));
 364 # endif
 365 _GL_CXXALIASWARN (strdup);
 366 #elif defined GNULIB_POSIXCHECK
 367 # undef strdup
 368 # if HAVE_RAW_DECL_STRDUP
 369 _GL_WARN_ON_USE (strdup, "strdup is unportable - "
 370                  "use gnulib module strdup for portability");
 371 # endif
 372 #endif
 373
 374 /* Append no more than N characters from SRC onto DEST.  */
 375 #if @GNULIB_STRNCAT@
 376 # if @REPLACE_STRNCAT@
 377 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 378 #   undef strncat
 379 #   define strncat rpl_strncat
 380 #  endif
 381 _GL_FUNCDECL_RPL (strncat, char *, (char *dest, const char *src, size_t n)
 382                                    _GL_ARG_NONNULL ((1, 2)));
 383 _GL_CXXALIAS_RPL (strncat, char *, (char *dest, const char *src, size_t n));
 384 # else
 385 _GL_CXXALIAS_SYS (strncat, char *, (char *dest, const char *src, size_t n));
 386 # endif
 387 _GL_CXXALIASWARN (strncat);
 388 #elif defined GNULIB_POSIXCHECK
 389 # undef strncat
 390 # if HAVE_RAW_DECL_STRNCAT
 391 _GL_WARN_ON_USE (strncat, "strncat is unportable - "
 392                  "use gnulib module strncat for portability");
 393 # endif
 394 #endif
 395
 396 /* Return a newly allocated copy of at most N bytes of STRING.  */
 397 #if @GNULIB_STRNDUP@
 398 # if @REPLACE_STRNDUP@
 399 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 400 #   undef strndup
 401 #   define strndup rpl_strndup
 402 #  endif
 403 _GL_FUNCDECL_RPL (strndup, char *, (char const *__string, size_t __n)
 404                                    _GL_ARG_NONNULL ((1)));
 405 _GL_CXXALIAS_RPL (strndup, char *, (char const *__string, size_t __n));
 406 # else
 407 #  if ! @HAVE_DECL_STRNDUP@
 408 _GL_FUNCDECL_SYS (strndup, char *, (char const *__string, size_t __n)
 409                                    _GL_ARG_NONNULL ((1)));
 410 #  endif
 411 _GL_CXXALIAS_SYS (strndup, char *, (char const *__string, size_t __n));
 412 # endif
 413 _GL_CXXALIASWARN (strndup);
 414 #elif defined GNULIB_POSIXCHECK
 415 # undef strndup
 416 # if HAVE_RAW_DECL_STRNDUP
 417 _GL_WARN_ON_USE (strndup, "strndup is unportable - "
 418                  "use gnulib module strndup for portability");
 419 # endif
 420 #endif
 421
 422 /* Find the length (number of bytes) of STRING, but scan at most
 423    MAXLEN bytes.  If no '\0' terminator is found in that many bytes,
 424    return MAXLEN.  */
 425 #if @GNULIB_STRNLEN@
 426 # if @REPLACE_STRNLEN@
 427 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 428 #   undef strnlen
 429 #   define strnlen rpl_strnlen
 430 #  endif
 431 _GL_FUNCDECL_RPL (strnlen, size_t, (char const *__string, size_t __maxlen)
 432                                    _GL_ATTRIBUTE_PURE
 433                                    _GL_ARG_NONNULL ((1)));
 434 _GL_CXXALIAS_RPL (strnlen, size_t, (char const *__string, size_t __maxlen));
 435 # else
 436 #  if ! @HAVE_DECL_STRNLEN@
 437 _GL_FUNCDECL_SYS (strnlen, size_t, (char const *__string, size_t __maxlen)
 438                                    _GL_ATTRIBUTE_PURE
 439                                    _GL_ARG_NONNULL ((1)));
 440 #  endif
 441 _GL_CXXALIAS_SYS (strnlen, size_t, (char const *__string, size_t __maxlen));
 442 # endif
 443 _GL_CXXALIASWARN (strnlen);
 444 #elif defined GNULIB_POSIXCHECK
 445 # undef strnlen
 446 # if HAVE_RAW_DECL_STRNLEN
 447 _GL_WARN_ON_USE (strnlen, "strnlen is unportable - "
 448                  "use gnulib module strnlen for portability");
 449 # endif
 450 #endif
 451
 452 #if defined GNULIB_POSIXCHECK
 453 /* strcspn() assumes the second argument is a list of single-byte characters.
 454    Even in this simple case, it does not work with multibyte strings if the
 455    locale encoding is GB18030 and one of the characters to be searched is a
 456    digit.  */
 457 # undef strcspn
 458 /* Assume strcspn is always declared.  */
 459 _GL_WARN_ON_USE (strcspn, "strcspn cannot work correctly on character strings "
 460                  "in multibyte locales - "
 461                  "use mbscspn if you care about internationalization");
 462 #endif
 463
 464 /* Find the first occurrence in S of any character in ACCEPT.  */
 465 #if @GNULIB_STRPBRK@
 466 # if ! @HAVE_STRPBRK@
 467 _GL_FUNCDECL_SYS (strpbrk, char *, (char const *__s, char const *__accept)
 468                                    _GL_ATTRIBUTE_PURE
 469                                    _GL_ARG_NONNULL ((1, 2)));
 470 # endif
 471   /* On some systems, this function is defined as an overloaded function:
 472        extern "C" { const char * strpbrk (const char *, const char *); }
 473        extern "C++" { char * strpbrk (char *, const char *); }  */
 474 _GL_CXXALIAS_SYS_CAST2 (strpbrk,
 475                         char *, (char const *__s, char const *__accept),
 476                         const char *, (char const *__s, char const *__accept));
 477 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
 478      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
 479 _GL_CXXALIASWARN1 (strpbrk, char *, (char *__s, char const *__accept));
 480 _GL_CXXALIASWARN1 (strpbrk, char const *,
 481                    (char const *__s, char const *__accept));
 482 # else
 483 _GL_CXXALIASWARN (strpbrk);
 484 # endif
 485 # if defined GNULIB_POSIXCHECK
 486 /* strpbrk() assumes the second argument is a list of single-byte characters.
 487    Even in this simple case, it does not work with multibyte strings if the
 488    locale encoding is GB18030 and one of the characters to be searched is a
 489    digit.  */
 490 #  undef strpbrk
 491 _GL_WARN_ON_USE (strpbrk, "strpbrk cannot work correctly on character strings "
 492                  "in multibyte locales - "
 493                  "use mbspbrk if you care about internationalization");
 494 # endif
 495 #elif defined GNULIB_POSIXCHECK
 496 # undef strpbrk
 497 # if HAVE_RAW_DECL_STRPBRK
 498 _GL_WARN_ON_USE (strpbrk, "strpbrk is unportable - "
 499                  "use gnulib module strpbrk for portability");
 500 # endif
 501 #endif
 502
 503 #if defined GNULIB_POSIXCHECK
 504 /* strspn() assumes the second argument is a list of single-byte characters.
 505    Even in this simple case, it cannot work with multibyte strings.  */
 506 # undef strspn
 507 /* Assume strspn is always declared.  */
 508 _GL_WARN_ON_USE (strspn, "strspn cannot work correctly on character strings "
 509                  "in multibyte locales - "
 510                  "use mbsspn if you care about internationalization");
 511 #endif
 512
 513 #if defined GNULIB_POSIXCHECK
 514 /* strrchr() does not work with multibyte strings if the locale encoding is
 515    GB18030 and the character to be searched is a digit.  */
 516 # undef strrchr
 517 /* Assume strrchr is always declared.  */
 518 _GL_WARN_ON_USE (strrchr, "strrchr cannot work correctly on character strings "
 519                  "in some multibyte locales - "
 520                  "use mbsrchr if you care about internationalization");
 521 #endif
 522
 523 /* Search the next delimiter (char listed in DELIM) starting at *STRINGP.
 524    If one is found, overwrite it with a NUL, and advance *STRINGP
 525    to point to the next char after it.  Otherwise, set *STRINGP to NULL.
 526    If *STRINGP was already NULL, nothing happens.
 527    Return the old value of *STRINGP.
 528
 529    This is a variant of strtok() that is multithread-safe and supports
 530    empty fields.
 531
 532    Caveat: It modifies the original string.
 533    Caveat: These functions cannot be used on constant strings.
 534    Caveat: The identity of the delimiting character is lost.
 535    Caveat: It doesn't work with multibyte strings unless all of the delimiter
 536            characters are ASCII characters < 0x30.
 537
 538    See also strtok_r().  */
 539 #if @GNULIB_STRSEP@
 540 # if ! @HAVE_STRSEP@
 541 _GL_FUNCDECL_SYS (strsep, char *,
 542                   (char **restrict __stringp, char const *restrict __delim)
 543                   _GL_ARG_NONNULL ((1, 2)));
 544 # endif
 545 _GL_CXXALIAS_SYS (strsep, char *,
 546                   (char **restrict __stringp, char const *restrict __delim));
 547 _GL_CXXALIASWARN (strsep);
 548 # if defined GNULIB_POSIXCHECK
 549 #  undef strsep
 550 _GL_WARN_ON_USE (strsep, "strsep cannot work correctly on character strings "
 551                  "in multibyte locales - "
 552                  "use mbssep if you care about internationalization");
 553 # endif
 554 #elif defined GNULIB_POSIXCHECK
 555 # undef strsep
 556 # if HAVE_RAW_DECL_STRSEP
 557 _GL_WARN_ON_USE (strsep, "strsep is unportable - "
 558                  "use gnulib module strsep for portability");
 559 # endif
 560 #endif
 561
 562 #if @GNULIB_STRSTR@
 563 # if @REPLACE_STRSTR@
 564 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 565 #   define strstr rpl_strstr
 566 #  endif
 567 _GL_FUNCDECL_RPL (strstr, char *, (const char *haystack, const char *needle)
 568                                   _GL_ATTRIBUTE_PURE
 569                                   _GL_ARG_NONNULL ((1, 2)));
 570 _GL_CXXALIAS_RPL (strstr, char *, (const char *haystack, const char *needle));
 571 # else
 572   /* On some systems, this function is defined as an overloaded function:
 573        extern "C++" { const char * strstr (const char *, const char *); }
 574        extern "C++" { char * strstr (char *, const char *); }  */
 575 _GL_CXXALIAS_SYS_CAST2 (strstr,
 576                         char *, (const char *haystack, const char *needle),
 577                         const char *, (const char *haystack, const char *needle));
 578 # endif
 579 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
 580      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
 581 _GL_CXXALIASWARN1 (strstr, char *, (char *haystack, const char *needle));
 582 _GL_CXXALIASWARN1 (strstr, const char *,
 583                    (const char *haystack, const char *needle));
 584 # else
 585 _GL_CXXALIASWARN (strstr);
 586 # endif
 587 #elif defined GNULIB_POSIXCHECK
 588 /* strstr() does not work with multibyte strings if the locale encoding is
 589    different from UTF-8:
 590    POSIX says that it operates on "strings", and "string" in POSIX is defined
 591    as a sequence of bytes, not of characters.  */
 592 # undef strstr
 593 /* Assume strstr is always declared.  */
 594 _GL_WARN_ON_USE (strstr, "strstr is quadratic on many systems, and cannot "
 595                  "work correctly on character strings in most "
 596                  "multibyte locales - "
 597                  "use mbsstr if you care about internationalization, "
 598                  "or use strstr if you care about speed");
 599 #endif
 600
 601 /* Find the first occurrence of NEEDLE in HAYSTACK, using case-insensitive
 602    comparison.  */
 603 #if @GNULIB_STRCASESTR@
 604 # if @REPLACE_STRCASESTR@
 605 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 606 #   define strcasestr rpl_strcasestr
 607 #  endif
 608 _GL_FUNCDECL_RPL (strcasestr, char *,
 609                   (const char *haystack, const char *needle)
 610                   _GL_ATTRIBUTE_PURE
 611                   _GL_ARG_NONNULL ((1, 2)));
 612 _GL_CXXALIAS_RPL (strcasestr, char *,
 613                   (const char *haystack, const char *needle));
 614 # else
 615 #  if ! @HAVE_STRCASESTR@
 616 _GL_FUNCDECL_SYS (strcasestr, char *,
 617                   (const char *haystack, const char *needle)
 618                   _GL_ATTRIBUTE_PURE
 619                   _GL_ARG_NONNULL ((1, 2)));
 620 #  endif
 621   /* On some systems, this function is defined as an overloaded function:
 622        extern "C++" { const char * strcasestr (const char *, const char *); }
 623        extern "C++" { char * strcasestr (char *, const char *); }  */
 624 _GL_CXXALIAS_SYS_CAST2 (strcasestr,
 625                         char *, (const char *haystack, const char *needle),
 626                         const char *, (const char *haystack, const char *needle));
 627 # endif
 628 # if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \
 629      && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
 630 _GL_CXXALIASWARN1 (strcasestr, char *, (char *haystack, const char *needle));
 631 _GL_CXXALIASWARN1 (strcasestr, const char *,
 632                    (const char *haystack, const char *needle));
 633 # else
 634 _GL_CXXALIASWARN (strcasestr);
 635 # endif
 636 #elif defined GNULIB_POSIXCHECK
 637 /* strcasestr() does not work with multibyte strings:
 638    It is a glibc extension, and glibc implements it only for unibyte
 639    locales.  */
 640 # undef strcasestr
 641 # if HAVE_RAW_DECL_STRCASESTR
 642 _GL_WARN_ON_USE (strcasestr, "strcasestr does work correctly on character "
 643                  "strings in multibyte locales - "
 644                  "use mbscasestr if you care about "
 645                  "internationalization, or use c-strcasestr if you want "
 646                  "a locale independent function");
 647 # endif
 648 #endif
 649
 650 /* Parse S into tokens separated by characters in DELIM.
 651    If S is NULL, the saved pointer in SAVE_PTR is used as
 652    the next starting point.  For example:
 653         char s[] = "-abc-=-def";
 654         char *sp;
 655         x = strtok_r(s, "-", &sp);      // x = "abc", sp = "=-def"
 656         x = strtok_r(NULL, "-=", &sp);  // x = "def", sp = NULL
 657         x = strtok_r(NULL, "=", &sp);   // x = NULL
 658                 // s = "abc\0-def\0"
 659
 660    This is a variant of strtok() that is multithread-safe.
 661
 662    For the POSIX documentation for this function, see:
 663    http://www.opengroup.org/susv3xsh/strtok.html
 664
 665    Caveat: It modifies the original string.
 666    Caveat: These functions cannot be used on constant strings.
 667    Caveat: The identity of the delimiting character is lost.
 668    Caveat: It doesn't work with multibyte strings unless all of the delimiter
 669            characters are ASCII characters < 0x30.
 670
 671    See also strsep().  */
 672 #if @GNULIB_STRTOK_R@
 673 # if @REPLACE_STRTOK_R@
 674 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 675 #   undef strtok_r
 676 #   define strtok_r rpl_strtok_r
 677 #  endif
 678 _GL_FUNCDECL_RPL (strtok_r, char *,
 679                   (char *restrict s, char const *restrict delim,
 680                    char **restrict save_ptr)
 681                   _GL_ARG_NONNULL ((2, 3)));
 682 _GL_CXXALIAS_RPL (strtok_r, char *,
 683                   (char *restrict s, char const *restrict delim,
 684                    char **restrict save_ptr));
 685 # else
 686 #  if @UNDEFINE_STRTOK_R@ || defined GNULIB_POSIXCHECK
 687 #   undef strtok_r
 688 #  endif
 689 #  if ! @HAVE_DECL_STRTOK_R@
 690 _GL_FUNCDECL_SYS (strtok_r, char *,
 691                   (char *restrict s, char const *restrict delim,
 692                    char **restrict save_ptr)
 693                   _GL_ARG_NONNULL ((2, 3)));
 694 #  endif
 695 _GL_CXXALIAS_SYS (strtok_r, char *,
 696                   (char *restrict s, char const *restrict delim,
 697                    char **restrict save_ptr));
 698 # endif
 699 _GL_CXXALIASWARN (strtok_r);
 700 # if defined GNULIB_POSIXCHECK
 701 _GL_WARN_ON_USE (strtok_r, "strtok_r cannot work correctly on character "
 702                  "strings in multibyte locales - "
 703                  "use mbstok_r if you care about internationalization");
 704 # endif
 705 #elif defined GNULIB_POSIXCHECK
 706 # undef strtok_r
 707 # if HAVE_RAW_DECL_STRTOK_R
 708 _GL_WARN_ON_USE (strtok_r, "strtok_r is unportable - "
 709                  "use gnulib module strtok_r for portability");
 710 # endif
 711 #endif
 712
 713
 714 /* The following functions are not specified by POSIX.  They are gnulib
 715    extensions.  */
 716
 717 #if @GNULIB_MBSLEN@
 718 /* Return the number of multibyte characters in the character string STRING.
 719    This considers multibyte characters, unlike strlen, which counts bytes.  */
 720 # ifdef __MirBSD__  /* MirBSD defines mbslen as a macro.  Override it.  */
 721 #  undef mbslen
 722 # endif
 723 # if @HAVE_MBSLEN@  /* AIX, OSF/1, MirBSD define mbslen already in libc.  */
 724 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 725 #   define mbslen rpl_mbslen
 726 #  endif
 727 _GL_FUNCDECL_RPL (mbslen, size_t, (const char *string)
 728                                   _GL_ATTRIBUTE_PURE
 729                                   _GL_ARG_NONNULL ((1)));
 730 _GL_CXXALIAS_RPL (mbslen, size_t, (const char *string));
 731 # else
 732 _GL_FUNCDECL_SYS (mbslen, size_t, (const char *string)
 733                                   _GL_ATTRIBUTE_PURE
 734                                   _GL_ARG_NONNULL ((1)));
 735 _GL_CXXALIAS_SYS (mbslen, size_t, (const char *string));
 736 # endif
 737 _GL_CXXALIASWARN (mbslen);
 738 #endif
 739
 740 #if @GNULIB_MBSNLEN@
 741 /* Return the number of multibyte characters in the character string starting
 742    at STRING and ending at STRING + LEN.  */
 743 _GL_EXTERN_C size_t mbsnlen (const char *string, size_t len)
 744      _GL_ATTRIBUTE_PURE
 745      _GL_ARG_NONNULL ((1));
 746 #endif
 747
 748 #if @GNULIB_MBSCHR@
 749 /* Locate the first single-byte character C in the character string STRING,
 750    and return a pointer to it.  Return NULL if C is not found in STRING.
 751    Unlike strchr(), this function works correctly in multibyte locales with
 752    encodings such as GB18030.  */
 753 # if defined __hpux
 754 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 755 #   define mbschr rpl_mbschr /* avoid collision with HP-UX function */
 756 #  endif
 757 _GL_FUNCDECL_RPL (mbschr, char *, (const char *string, int c)
 758                                   _GL_ATTRIBUTE_PURE
 759                                   _GL_ARG_NONNULL ((1)));
 760 _GL_CXXALIAS_RPL (mbschr, char *, (const char *string, int c));
 761 # else
 762 _GL_FUNCDECL_SYS (mbschr, char *, (const char *string, int c)
 763                                   _GL_ATTRIBUTE_PURE
 764                                   _GL_ARG_NONNULL ((1)));
 765 _GL_CXXALIAS_SYS (mbschr, char *, (const char *string, int c));
 766 # endif
 767 _GL_CXXALIASWARN (mbschr);
 768 #endif
 769
 770 #if @GNULIB_MBSRCHR@
 771 /* Locate the last single-byte character C in the character string STRING,
 772    and return a pointer to it.  Return NULL if C is not found in STRING.
 773    Unlike strrchr(), this function works correctly in multibyte locales with
 774    encodings such as GB18030.  */
 775 # if defined __hpux || defined __INTERIX
 776 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 777 #   define mbsrchr rpl_mbsrchr /* avoid collision with system function */
 778 #  endif
 779 _GL_FUNCDECL_RPL (mbsrchr, char *, (const char *string, int c)
 780                                    _GL_ATTRIBUTE_PURE
 781                                    _GL_ARG_NONNULL ((1)));
 782 _GL_CXXALIAS_RPL (mbsrchr, char *, (const char *string, int c));
 783 # else
 784 _GL_FUNCDECL_SYS (mbsrchr, char *, (const char *string, int c)
 785                                    _GL_ATTRIBUTE_PURE
 786                                    _GL_ARG_NONNULL ((1)));
 787 _GL_CXXALIAS_SYS (mbsrchr, char *, (const char *string, int c));
 788 # endif
 789 _GL_CXXALIASWARN (mbsrchr);
 790 #endif
 791
 792 #if @GNULIB_MBSSTR@
 793 /* Find the first occurrence of the character string NEEDLE in the character
 794    string HAYSTACK.  Return NULL if NEEDLE is not found in HAYSTACK.
 795    Unlike strstr(), this function works correctly in multibyte locales with
 796    encodings different from UTF-8.  */
 797 _GL_EXTERN_C char * mbsstr (const char *haystack, const char *needle)
 798      _GL_ATTRIBUTE_PURE
 799      _GL_ARG_NONNULL ((1, 2));
 800 #endif
 801
 802 #if @GNULIB_MBSCASECMP@
 803 /* Compare the character strings S1 and S2, ignoring case, returning less than,
 804    equal to or greater than zero if S1 is lexicographically less than, equal to
 805    or greater than S2.
 806    Note: This function may, in multibyte locales, return 0 for strings of
 807    different lengths!
 808    Unlike strcasecmp(), this function works correctly in multibyte locales.  */
 809 _GL_EXTERN_C int mbscasecmp (const char *s1, const char *s2)
 810      _GL_ATTRIBUTE_PURE
 811      _GL_ARG_NONNULL ((1, 2));
 812 #endif
 813
 814 #if @GNULIB_MBSNCASECMP@
 815 /* Compare the initial segment of the character string S1 consisting of at most
 816    N characters with the initial segment of the character string S2 consisting
 817    of at most N characters, ignoring case, returning less than, equal to or
 818    greater than zero if the initial segment of S1 is lexicographically less
 819    than, equal to or greater than the initial segment of S2.
 820    Note: This function may, in multibyte locales, return 0 for initial segments
 821    of different lengths!
 822    Unlike strncasecmp(), this function works correctly in multibyte locales.
 823    But beware that N is not a byte count but a character count!  */
 824 _GL_EXTERN_C int mbsncasecmp (const char *s1, const char *s2, size_t n)
 825      _GL_ATTRIBUTE_PURE
 826      _GL_ARG_NONNULL ((1, 2));
 827 #endif
 828
 829 #if @GNULIB_MBSPCASECMP@
 830 /* Compare the initial segment of the character string STRING consisting of
 831    at most mbslen (PREFIX) characters with the character string PREFIX,
 832    ignoring case.  If the two match, return a pointer to the first byte
 833    after this prefix in STRING.  Otherwise, return NULL.
 834    Note: This function may, in multibyte locales, return non-NULL if STRING
 835    is of smaller length than PREFIX!
 836    Unlike strncasecmp(), this function works correctly in multibyte
 837    locales.  */
 838 _GL_EXTERN_C char * mbspcasecmp (const char *string, const char *prefix)
 839      _GL_ATTRIBUTE_PURE
 840      _GL_ARG_NONNULL ((1, 2));
 841 #endif
 842
 843 #if @GNULIB_MBSCASESTR@
 844 /* Find the first occurrence of the character string NEEDLE in the character
 845    string HAYSTACK, using case-insensitive comparison.
 846    Note: This function may, in multibyte locales, return success even if
 847    strlen (haystack) < strlen (needle) !
 848    Unlike strcasestr(), this function works correctly in multibyte locales.  */
 849 _GL_EXTERN_C char * mbscasestr (const char *haystack, const char *needle)
 850      _GL_ATTRIBUTE_PURE
 851      _GL_ARG_NONNULL ((1, 2));
 852 #endif
 853
 854 #if @GNULIB_MBSCSPN@
 855 /* Find the first occurrence in the character string STRING of any character
 856    in the character string ACCEPT.  Return the number of bytes from the
 857    beginning of the string to this occurrence, or to the end of the string
 858    if none exists.
 859    Unlike strcspn(), this function works correctly in multibyte locales.  */
 860 _GL_EXTERN_C size_t mbscspn (const char *string, const char *accept)
 861      _GL_ATTRIBUTE_PURE
 862      _GL_ARG_NONNULL ((1, 2));
 863 #endif
 864
 865 #if @GNULIB_MBSPBRK@
 866 /* Find the first occurrence in the character string STRING of any character
 867    in the character string ACCEPT.  Return the pointer to it, or NULL if none
 868    exists.
 869    Unlike strpbrk(), this function works correctly in multibyte locales.  */
 870 # if defined __hpux
 871 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 872 #   define mbspbrk rpl_mbspbrk /* avoid collision with HP-UX function */
 873 #  endif
 874 _GL_FUNCDECL_RPL (mbspbrk, char *, (const char *string, const char *accept)
 875                                    _GL_ATTRIBUTE_PURE
 876                                    _GL_ARG_NONNULL ((1, 2)));
 877 _GL_CXXALIAS_RPL (mbspbrk, char *, (const char *string, const char *accept));
 878 # else
 879 _GL_FUNCDECL_SYS (mbspbrk, char *, (const char *string, const char *accept)
 880                                    _GL_ATTRIBUTE_PURE
 881                                    _GL_ARG_NONNULL ((1, 2)));
 882 _GL_CXXALIAS_SYS (mbspbrk, char *, (const char *string, const char *accept));
 883 # endif
 884 _GL_CXXALIASWARN (mbspbrk);
 885 #endif
 886
 887 #if @GNULIB_MBSSPN@
 888 /* Find the first occurrence in the character string STRING of any character
 889    not in the character string REJECT.  Return the number of bytes from the
 890    beginning of the string to this occurrence, or to the end of the string
 891    if none exists.
 892    Unlike strspn(), this function works correctly in multibyte locales.  */
 893 _GL_EXTERN_C size_t mbsspn (const char *string, const char *reject)
 894      _GL_ATTRIBUTE_PURE
 895      _GL_ARG_NONNULL ((1, 2));
 896 #endif
 897
 898 #if @GNULIB_MBSSEP@
 899 /* Search the next delimiter (multibyte character listed in the character
 900    string DELIM) starting at the character string *STRINGP.
 901    If one is found, overwrite it with a NUL, and advance *STRINGP to point
 902    to the next multibyte character after it.  Otherwise, set *STRINGP to NULL.
 903    If *STRINGP was already NULL, nothing happens.
 904    Return the old value of *STRINGP.
 905
 906    This is a variant of mbstok_r() that supports empty fields.
 907
 908    Caveat: It modifies the original string.
 909    Caveat: These functions cannot be used on constant strings.
 910    Caveat: The identity of the delimiting character is lost.
 911
 912    See also mbstok_r().  */
 913 _GL_EXTERN_C char * mbssep (char **stringp, const char *delim)
 914      _GL_ARG_NONNULL ((1, 2));
 915 #endif
 916
 917 #if @GNULIB_MBSTOK_R@
 918 /* Parse the character string STRING into tokens separated by characters in
 919    the character string DELIM.
 920    If STRING is NULL, the saved pointer in SAVE_PTR is used as
 921    the next starting point.  For example:
 922         char s[] = "-abc-=-def";
 923         char *sp;
 924         x = mbstok_r(s, "-", &sp);      // x = "abc", sp = "=-def"
 925         x = mbstok_r(NULL, "-=", &sp);  // x = "def", sp = NULL
 926         x = mbstok_r(NULL, "=", &sp);   // x = NULL
 927                 // s = "abc\0-def\0"
 928
 929    Caveat: It modifies the original string.
 930    Caveat: These functions cannot be used on constant strings.
 931    Caveat: The identity of the delimiting character is lost.
 932
 933    See also mbssep().  */
 934 _GL_EXTERN_C char * mbstok_r (char *string, const char *delim, char **save_ptr)
 935      _GL_ARG_NONNULL ((2, 3));
 936 #endif
 937
 938 /* Map any int, typically from errno, into an error message.  */
 939 #if @GNULIB_STRERROR@
 940 # if @REPLACE_STRERROR@
 941 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 942 #   undef strerror
 943 #   define strerror rpl_strerror
 944 #  endif
 945 _GL_FUNCDECL_RPL (strerror, char *, (int));
 946 _GL_CXXALIAS_RPL (strerror, char *, (int));
 947 # else
 948 _GL_CXXALIAS_SYS (strerror, char *, (int));
 949 # endif
 950 _GL_CXXALIASWARN (strerror);
 951 #elif defined GNULIB_POSIXCHECK
 952 # undef strerror
 953 /* Assume strerror is always declared.  */
 954 _GL_WARN_ON_USE (strerror, "strerror is unportable - "
 955                  "use gnulib module strerror to guarantee non-NULL result");
 956 #endif
 957
 958 /* Map any int, typically from errno, into an error message.  Multithread-safe.
 959    Uses the POSIX declaration, not the glibc declaration.  */
 960 #if @GNULIB_STRERROR_R@
 961 # if @REPLACE_STRERROR_R@
 962 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 963 #   undef strerror_r
 964 #   define strerror_r rpl_strerror_r
 965 #  endif
 966 _GL_FUNCDECL_RPL (strerror_r, int, (int errnum, char *buf, size_t buflen)
 967                                    _GL_ARG_NONNULL ((2)));
 968 _GL_CXXALIAS_RPL (strerror_r, int, (int errnum, char *buf, size_t buflen));
 969 # else
 970 #  if !@HAVE_DECL_STRERROR_R@
 971 _GL_FUNCDECL_SYS (strerror_r, int, (int errnum, char *buf, size_t buflen)
 972                                    _GL_ARG_NONNULL ((2)));
 973 #  endif
 974 _GL_CXXALIAS_SYS (strerror_r, int, (int errnum, char *buf, size_t buflen));
 975 # endif
 976 # if @HAVE_DECL_STRERROR_R@
 977 _GL_CXXALIASWARN (strerror_r);
 978 # endif
 979 #elif defined GNULIB_POSIXCHECK
 980 # undef strerror_r
 981 # if HAVE_RAW_DECL_STRERROR_R
 982 _GL_WARN_ON_USE (strerror_r, "strerror_r is unportable - "
 983                  "use gnulib module strerror_r-posix for portability");
 984 # endif
 985 #endif
 986
 987 #if @GNULIB_STRSIGNAL@
 988 # if @REPLACE_STRSIGNAL@
 989 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 990 #   define strsignal rpl_strsignal
 991 #  endif
 992 _GL_FUNCDECL_RPL (strsignal, char *, (int __sig));
 993 _GL_CXXALIAS_RPL (strsignal, char *, (int __sig));
 994 # else
 995 #  if ! @HAVE_DECL_STRSIGNAL@
 996 _GL_FUNCDECL_SYS (strsignal, char *, (int __sig));
 997 #  endif
 998 /* Need to cast, because on Cygwin 1.5.x systems, the return type is
 999    'const char *'.  */
1000 _GL_CXXALIAS_SYS_CAST (strsignal, char *, (int __sig));
1001 # endif
1002 _GL_CXXALIASWARN (strsignal);
1003 #elif defined GNULIB_POSIXCHECK
1004 # undef strsignal
1005 # if HAVE_RAW_DECL_STRSIGNAL
1006 _GL_WARN_ON_USE (strsignal, "strsignal is unportable - "
1007                  "use gnulib module strsignal for portability");
1008 # endif
1009 #endif
1010
1011 #if @GNULIB_STRVERSCMP@
1012 # if !@HAVE_STRVERSCMP@
1013 _GL_FUNCDECL_SYS (strverscmp, int, (const char *, const char *)
1014                                    _GL_ATTRIBUTE_PURE
1015                                    _GL_ARG_NONNULL ((1, 2)));
1016 # endif
1017 _GL_CXXALIAS_SYS (strverscmp, int, (const char *, const char *));
1018 _GL_CXXALIASWARN (strverscmp);
1019 #elif defined GNULIB_POSIXCHECK
1020 # undef strverscmp
1021 # if HAVE_RAW_DECL_STRVERSCMP
1022 _GL_WARN_ON_USE (strverscmp, "strverscmp is unportable - "
1023                  "use gnulib module strverscmp for portability");
1024 # endif
1025 #endif
1026
1027
1028 #endif /* _@GUARD_PREFIX@_STRING_H */
1029 #endif /* _@GUARD_PREFIX@_STRING_H */