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