root/lib/string.in.h

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