root/maint/gnulib/lib/string.in.h

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