gl/string.in.h

   1 /* A GNU-like <string.h>.
   2
   3    Copyright (C) 1995-1996, 2001-2012 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) _GL_ARG_NONNULL ((1)));
 728 _GL_CXXALIAS_RPL (mbslen, size_t, (const char *string));
 729 # else
 730 _GL_FUNCDECL_SYS (mbslen, size_t, (const char *string) _GL_ARG_NONNULL ((1)));
 731 _GL_CXXALIAS_SYS (mbslen, size_t, (const char *string));
 732 # endif
 733 _GL_CXXALIASWARN (mbslen);
 734 #endif
 735
 736 #if @GNULIB_MBSNLEN@
 737 /* Return the number of multibyte characters in the character string starting
 738    at STRING and ending at STRING + LEN.  */
 739 _GL_EXTERN_C size_t mbsnlen (const char *string, size_t len)
 740      _GL_ARG_NONNULL ((1));
 741 #endif
 742
 743 #if @GNULIB_MBSCHR@
 744 /* Locate the first single-byte character C in the character string STRING,
 745    and return a pointer to it.  Return NULL if C is not found in STRING.
 746    Unlike strchr(), this function works correctly in multibyte locales with
 747    encodings such as GB18030.  */
 748 # if defined __hpux
 749 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 750 #   define mbschr rpl_mbschr /* avoid collision with HP-UX function */
 751 #  endif
 752 _GL_FUNCDECL_RPL (mbschr, char *, (const char *string, int c)
 753                                   _GL_ARG_NONNULL ((1)));
 754 _GL_CXXALIAS_RPL (mbschr, char *, (const char *string, int c));
 755 # else
 756 _GL_FUNCDECL_SYS (mbschr, char *, (const char *string, int c)
 757                                   _GL_ARG_NONNULL ((1)));
 758 _GL_CXXALIAS_SYS (mbschr, char *, (const char *string, int c));
 759 # endif
 760 _GL_CXXALIASWARN (mbschr);
 761 #endif
 762
 763 #if @GNULIB_MBSRCHR@
 764 /* Locate the last single-byte character C in the character string STRING,
 765    and return a pointer to it.  Return NULL if C is not found in STRING.
 766    Unlike strrchr(), this function works correctly in multibyte locales with
 767    encodings such as GB18030.  */
 768 # if defined __hpux || defined __INTERIX
 769 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 770 #   define mbsrchr rpl_mbsrchr /* avoid collision with system function */
 771 #  endif
 772 _GL_FUNCDECL_RPL (mbsrchr, char *, (const char *string, int c)
 773                                    _GL_ARG_NONNULL ((1)));
 774 _GL_CXXALIAS_RPL (mbsrchr, char *, (const char *string, int c));
 775 # else
 776 _GL_FUNCDECL_SYS (mbsrchr, char *, (const char *string, int c)
 777                                    _GL_ARG_NONNULL ((1)));
 778 _GL_CXXALIAS_SYS (mbsrchr, char *, (const char *string, int c));
 779 # endif
 780 _GL_CXXALIASWARN (mbsrchr);
 781 #endif
 782
 783 #if @GNULIB_MBSSTR@
 784 /* Find the first occurrence of the character string NEEDLE in the character
 785    string HAYSTACK.  Return NULL if NEEDLE is not found in HAYSTACK.
 786    Unlike strstr(), this function works correctly in multibyte locales with
 787    encodings different from UTF-8.  */
 788 _GL_EXTERN_C char * mbsstr (const char *haystack, const char *needle)
 789      _GL_ARG_NONNULL ((1, 2));
 790 #endif
 791
 792 #if @GNULIB_MBSCASECMP@
 793 /* Compare the character strings S1 and S2, ignoring case, returning less than,
 794    equal to or greater than zero if S1 is lexicographically less than, equal to
 795    or greater than S2.
 796    Note: This function may, in multibyte locales, return 0 for strings of
 797    different lengths!
 798    Unlike strcasecmp(), this function works correctly in multibyte locales.  */
 799 _GL_EXTERN_C int mbscasecmp (const char *s1, const char *s2)
 800      _GL_ARG_NONNULL ((1, 2));
 801 #endif
 802
 803 #if @GNULIB_MBSNCASECMP@
 804 /* Compare the initial segment of the character string S1 consisting of at most
 805    N characters with the initial segment of the character string S2 consisting
 806    of at most N characters, ignoring case, returning less than, equal to or
 807    greater than zero if the initial segment of S1 is lexicographically less
 808    than, equal to or greater than the initial segment of S2.
 809    Note: This function may, in multibyte locales, return 0 for initial segments
 810    of different lengths!
 811    Unlike strncasecmp(), this function works correctly in multibyte locales.
 812    But beware that N is not a byte count but a character count!  */
 813 _GL_EXTERN_C int mbsncasecmp (const char *s1, const char *s2, size_t n)
 814      _GL_ARG_NONNULL ((1, 2));
 815 #endif
 816
 817 #if @GNULIB_MBSPCASECMP@
 818 /* Compare the initial segment of the character string STRING consisting of
 819    at most mbslen (PREFIX) characters with the character string PREFIX,
 820    ignoring case.  If the two match, return a pointer to the first byte
 821    after this prefix in STRING.  Otherwise, return NULL.
 822    Note: This function may, in multibyte locales, return non-NULL if STRING
 823    is of smaller length than PREFIX!
 824    Unlike strncasecmp(), this function works correctly in multibyte
 825    locales.  */
 826 _GL_EXTERN_C char * mbspcasecmp (const char *string, const char *prefix)
 827      _GL_ARG_NONNULL ((1, 2));
 828 #endif
 829
 830 #if @GNULIB_MBSCASESTR@
 831 /* Find the first occurrence of the character string NEEDLE in the character
 832    string HAYSTACK, using case-insensitive comparison.
 833    Note: This function may, in multibyte locales, return success even if
 834    strlen (haystack) < strlen (needle) !
 835    Unlike strcasestr(), this function works correctly in multibyte locales.  */
 836 _GL_EXTERN_C char * mbscasestr (const char *haystack, const char *needle)
 837      _GL_ARG_NONNULL ((1, 2));
 838 #endif
 839
 840 #if @GNULIB_MBSCSPN@
 841 /* Find the first occurrence in the character string STRING of any character
 842    in the character string ACCEPT.  Return the number of bytes from the
 843    beginning of the string to this occurrence, or to the end of the string
 844    if none exists.
 845    Unlike strcspn(), this function works correctly in multibyte locales.  */
 846 _GL_EXTERN_C size_t mbscspn (const char *string, const char *accept)
 847      _GL_ARG_NONNULL ((1, 2));
 848 #endif
 849
 850 #if @GNULIB_MBSPBRK@
 851 /* Find the first occurrence in the character string STRING of any character
 852    in the character string ACCEPT.  Return the pointer to it, or NULL if none
 853    exists.
 854    Unlike strpbrk(), this function works correctly in multibyte locales.  */
 855 # if defined __hpux
 856 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 857 #   define mbspbrk rpl_mbspbrk /* avoid collision with HP-UX function */
 858 #  endif
 859 _GL_FUNCDECL_RPL (mbspbrk, char *, (const char *string, const char *accept)
 860                                    _GL_ARG_NONNULL ((1, 2)));
 861 _GL_CXXALIAS_RPL (mbspbrk, char *, (const char *string, const char *accept));
 862 # else
 863 _GL_FUNCDECL_SYS (mbspbrk, char *, (const char *string, const char *accept)
 864                                    _GL_ARG_NONNULL ((1, 2)));
 865 _GL_CXXALIAS_SYS (mbspbrk, char *, (const char *string, const char *accept));
 866 # endif
 867 _GL_CXXALIASWARN (mbspbrk);
 868 #endif
 869
 870 #if @GNULIB_MBSSPN@
 871 /* Find the first occurrence in the character string STRING of any character
 872    not in the character string REJECT.  Return the number of bytes from the
 873    beginning of the string to this occurrence, or to the end of the string
 874    if none exists.
 875    Unlike strspn(), this function works correctly in multibyte locales.  */
 876 _GL_EXTERN_C size_t mbsspn (const char *string, const char *reject)
 877      _GL_ARG_NONNULL ((1, 2));
 878 #endif
 879
 880 #if @GNULIB_MBSSEP@
 881 /* Search the next delimiter (multibyte character listed in the character
 882    string DELIM) starting at the character string *STRINGP.
 883    If one is found, overwrite it with a NUL, and advance *STRINGP to point
 884    to the next multibyte character after it.  Otherwise, set *STRINGP to NULL.
 885    If *STRINGP was already NULL, nothing happens.
 886    Return the old value of *STRINGP.
 887
 888    This is a variant of mbstok_r() that supports empty fields.
 889
 890    Caveat: It modifies the original string.
 891    Caveat: These functions cannot be used on constant strings.
 892    Caveat: The identity of the delimiting character is lost.
 893
 894    See also mbstok_r().  */
 895 _GL_EXTERN_C char * mbssep (char **stringp, const char *delim)
 896      _GL_ARG_NONNULL ((1, 2));
 897 #endif
 898
 899 #if @GNULIB_MBSTOK_R@
 900 /* Parse the character string STRING into tokens separated by characters in
 901    the character string DELIM.
 902    If STRING is NULL, the saved pointer in SAVE_PTR is used as
 903    the next starting point.  For example:
 904         char s[] = "-abc-=-def";
 905         char *sp;
 906         x = mbstok_r(s, "-", &sp);      // x = "abc", sp = "=-def"
 907         x = mbstok_r(NULL, "-=", &sp);  // x = "def", sp = NULL
 908         x = mbstok_r(NULL, "=", &sp);   // x = NULL
 909                 // s = "abc\0-def\0"
 910
 911    Caveat: It modifies the original string.
 912    Caveat: These functions cannot be used on constant strings.
 913    Caveat: The identity of the delimiting character is lost.
 914
 915    See also mbssep().  */
 916 _GL_EXTERN_C char * mbstok_r (char *string, const char *delim, char **save_ptr)
 917      _GL_ARG_NONNULL ((2, 3));
 918 #endif
 919
 920 /* Map any int, typically from errno, into an error message.  */
 921 #if @GNULIB_STRERROR@
 922 # if @REPLACE_STRERROR@
 923 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 924 #   undef strerror
 925 #   define strerror rpl_strerror
 926 #  endif
 927 _GL_FUNCDECL_RPL (strerror, char *, (int));
 928 _GL_CXXALIAS_RPL (strerror, char *, (int));
 929 # else
 930 _GL_CXXALIAS_SYS (strerror, char *, (int));
 931 # endif
 932 _GL_CXXALIASWARN (strerror);
 933 #elif defined GNULIB_POSIXCHECK
 934 # undef strerror
 935 /* Assume strerror is always declared.  */
 936 _GL_WARN_ON_USE (strerror, "strerror is unportable - "
 937                  "use gnulib module strerror to guarantee non-NULL result");
 938 #endif
 939
 940 /* Map any int, typically from errno, into an error message.  Multithread-safe.
 941    Uses the POSIX declaration, not the glibc declaration.  */
 942 #if @GNULIB_STRERROR_R@
 943 # if @REPLACE_STRERROR_R@
 944 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 945 #   undef strerror_r
 946 #   define strerror_r rpl_strerror_r
 947 #  endif
 948 _GL_FUNCDECL_RPL (strerror_r, int, (int errnum, char *buf, size_t buflen)
 949                                    _GL_ARG_NONNULL ((2)));
 950 _GL_CXXALIAS_RPL (strerror_r, int, (int errnum, char *buf, size_t buflen));
 951 # else
 952 #  if !@HAVE_DECL_STRERROR_R@
 953 _GL_FUNCDECL_SYS (strerror_r, int, (int errnum, char *buf, size_t buflen)
 954                                    _GL_ARG_NONNULL ((2)));
 955 #  endif
 956 _GL_CXXALIAS_SYS (strerror_r, int, (int errnum, char *buf, size_t buflen));
 957 # endif
 958 # if @HAVE_DECL_STRERROR_R@
 959 _GL_CXXALIASWARN (strerror_r);
 960 # endif
 961 #elif defined GNULIB_POSIXCHECK
 962 # undef strerror_r
 963 # if HAVE_RAW_DECL_STRERROR_R
 964 _GL_WARN_ON_USE (strerror_r, "strerror_r is unportable - "
 965                  "use gnulib module strerror_r-posix for portability");
 966 # endif
 967 #endif
 968
 969 #if @GNULIB_STRSIGNAL@
 970 # if @REPLACE_STRSIGNAL@
 971 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 972 #   define strsignal rpl_strsignal
 973 #  endif
 974 _GL_FUNCDECL_RPL (strsignal, char *, (int __sig));
 975 _GL_CXXALIAS_RPL (strsignal, char *, (int __sig));
 976 # else
 977 #  if ! @HAVE_DECL_STRSIGNAL@
 978 _GL_FUNCDECL_SYS (strsignal, char *, (int __sig));
 979 #  endif
 980 /* Need to cast, because on Cygwin 1.5.x systems, the return type is
 981    'const char *'.  */
 982 _GL_CXXALIAS_SYS_CAST (strsignal, char *, (int __sig));
 983 # endif
 984 _GL_CXXALIASWARN (strsignal);
 985 #elif defined GNULIB_POSIXCHECK
 986 # undef strsignal
 987 # if HAVE_RAW_DECL_STRSIGNAL
 988 _GL_WARN_ON_USE (strsignal, "strsignal is unportable - "
 989                  "use gnulib module strsignal for portability");
 990 # endif
 991 #endif
 992
 993 #if @GNULIB_STRVERSCMP@
 994 # if !@HAVE_STRVERSCMP@
 995 _GL_FUNCDECL_SYS (strverscmp, int, (const char *, const char *)
 996                                    _GL_ARG_NONNULL ((1, 2)));
 997 # endif
 998 _GL_CXXALIAS_SYS (strverscmp, int, (const char *, const char *));
 999 _GL_CXXALIASWARN (strverscmp);
1000 #elif defined GNULIB_POSIXCHECK
1001 # undef strverscmp
1002 # if HAVE_RAW_DECL_STRVERSCMP
1003 _GL_WARN_ON_USE (strverscmp, "strverscmp is unportable - "
1004                  "use gnulib module strverscmp for portability");
1005 # endif
1006 #endif
1007
1008
1009 #endif /* _@GUARD_PREFIX@_STRING_H */
1010 #endif /* _@GUARD_PREFIX@_STRING_H */