gnu/usr.bin/grep/libgreputils/string.h

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