1/* A GNU-like <string.h>. 2 3 Copyright (C) 1995-1996, 2001-2011 Free Software Foundation, Inc. 4 5 This program is free software; you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by 7 the Free Software Foundation; either version 3, or (at your option) 8 any later version. 9 10 This program is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program; if not, write to the Free Software Foundation, 17 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ 18 19#ifndef _@GUARD_PREFIX@_STRING_H 20 21#if __GNUC__ >= 3 22@PRAGMA_SYSTEM_HEADER@ 23#endif 24@PRAGMA_COLUMNS@ 25 26/* The include_next requires a split double-inclusion guard. */ 27#@INCLUDE_NEXT@ @NEXT_STRING_H@ 28 29#ifndef _@GUARD_PREFIX@_STRING_H 30#define _@GUARD_PREFIX@_STRING_H 31 32/* NetBSD 5.0 mis-defines NULL. */ 33#include <stddef.h> 34 35/* MirBSD defines mbslen as a macro. */ 36#if @GNULIB_MBSLEN@ && 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 (@GNULIB_STRSIGNAL@ || 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 57/* The definition of _GL_ARG_NONNULL is copied here. */ 58 59/* The definition of _GL_WARN_ON_USE is copied here. */ 60 61 62/* Find the index of the least-significant set bit. */ 63#if @GNULIB_FFSL@ 64# if !@HAVE_FFSL@ 65_GL_FUNCDECL_SYS (ffsl, int, (long int i)); 66# endif 67_GL_CXXALIAS_SYS (ffsl, int, (long int i)); 68_GL_CXXALIASWARN (ffsl); 69#elif defined GNULIB_POSIXCHECK 70# undef ffsl 71# if HAVE_RAW_DECL_FFSL 72_GL_WARN_ON_USE (ffsl, "ffsl is not portable - use the ffsl module"); 73# endif 74#endif 75 76 77/* Find the index of the least-significant set bit. */ 78#if @GNULIB_FFSLL@ 79# if !@HAVE_FFSLL@ 80_GL_FUNCDECL_SYS (ffsll, int, (long long int i)); 81# endif 82_GL_CXXALIAS_SYS (ffsll, int, (long long int i)); 83_GL_CXXALIASWARN (ffsll); 84#elif defined GNULIB_POSIXCHECK 85# undef ffsll 86# if HAVE_RAW_DECL_FFSLL 87_GL_WARN_ON_USE (ffsll, "ffsll is not portable - use the ffsll module"); 88# endif 89#endif 90 91 92/* Return the first instance of C within N bytes of S, or NULL. */ 93#if @GNULIB_MEMCHR@ 94# if @REPLACE_MEMCHR@ 95# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 96# define memchr rpl_memchr 97# endif 98_GL_FUNCDECL_RPL (memchr, void *, (void const *__s, int __c, size_t __n) 99 _GL_ATTRIBUTE_PURE 100 _GL_ARG_NONNULL ((1))); 101_GL_CXXALIAS_RPL (memchr, void *, (void const *__s, int __c, size_t __n)); 102# else 103# if ! @HAVE_MEMCHR@ 104_GL_FUNCDECL_SYS (memchr, void *, (void const *__s, int __c, size_t __n) 105 _GL_ATTRIBUTE_PURE 106 _GL_ARG_NONNULL ((1))); 107# endif 108 /* On some systems, this function is defined as an overloaded function: 109 extern "C" { const void * std::memchr (const void *, int, size_t); } 110 extern "C++" { void * std::memchr (void *, int, size_t); } */ 111_GL_CXXALIAS_SYS_CAST2 (memchr, 112 void *, (void const *__s, int __c, size_t __n), 113 void const *, (void const *__s, int __c, size_t __n)); 114# endif 115# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \ 116 && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) 117_GL_CXXALIASWARN1 (memchr, void *, (void *__s, int __c, size_t __n)); 118_GL_CXXALIASWARN1 (memchr, void const *, 119 (void const *__s, int __c, size_t __n)); 120# else 121_GL_CXXALIASWARN (memchr); 122# endif 123#elif defined GNULIB_POSIXCHECK 124# undef memchr 125/* Assume memchr is always declared. */ 126_GL_WARN_ON_USE (memchr, "memchr has platform-specific bugs - " 127 "use gnulib module memchr for portability" ); 128#endif 129 130/* Return the first occurrence of NEEDLE in HAYSTACK. */ 131#if @GNULIB_MEMMEM@ 132# if @REPLACE_MEMMEM@ 133# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 134# define memmem rpl_memmem 135# endif 136_GL_FUNCDECL_RPL (memmem, void *, 137 (void const *__haystack, size_t __haystack_len, 138 void const *__needle, size_t __needle_len) 139 _GL_ATTRIBUTE_PURE 140 _GL_ARG_NONNULL ((1, 3))); 141_GL_CXXALIAS_RPL (memmem, void *, 142 (void const *__haystack, size_t __haystack_len, 143 void const *__needle, size_t __needle_len)); 144# else 145# if ! @HAVE_DECL_MEMMEM@ 146_GL_FUNCDECL_SYS (memmem, void *, 147 (void const *__haystack, size_t __haystack_len, 148 void const *__needle, size_t __needle_len) 149 _GL_ATTRIBUTE_PURE 150 _GL_ARG_NONNULL ((1, 3))); 151# endif 152_GL_CXXALIAS_SYS (memmem, void *, 153 (void const *__haystack, size_t __haystack_len, 154 void const *__needle, size_t __needle_len)); 155# endif 156_GL_CXXALIASWARN (memmem); 157#elif defined GNULIB_POSIXCHECK 158# undef memmem 159# if HAVE_RAW_DECL_MEMMEM 160_GL_WARN_ON_USE (memmem, "memmem is unportable and often quadratic - " 161 "use gnulib module memmem-simple for portability, " 162 "and module memmem for speed" ); 163# endif 164#endif 165 166/* Copy N bytes of SRC to DEST, return pointer to bytes after the 167 last written byte. */ 168#if @GNULIB_MEMPCPY@ 169# if ! @HAVE_MEMPCPY@ 170_GL_FUNCDECL_SYS (mempcpy, void *, 171 (void *restrict __dest, void const *restrict __src, 172 size_t __n) 173 _GL_ARG_NONNULL ((1, 2))); 174# endif 175_GL_CXXALIAS_SYS (mempcpy, void *, 176 (void *restrict __dest, void const *restrict __src, 177 size_t __n)); 178_GL_CXXALIASWARN (mempcpy); 179#elif defined GNULIB_POSIXCHECK 180# undef mempcpy 181# if HAVE_RAW_DECL_MEMPCPY 182_GL_WARN_ON_USE (mempcpy, "mempcpy is unportable - " 183 "use gnulib module mempcpy for portability"); 184# endif 185#endif 186 187/* Search backwards through a block for a byte (specified as an int). */ 188#if @GNULIB_MEMRCHR@ 189# if ! @HAVE_DECL_MEMRCHR@ 190_GL_FUNCDECL_SYS (memrchr, void *, (void const *, int, size_t) 191 _GL_ATTRIBUTE_PURE 192 _GL_ARG_NONNULL ((1))); 193# endif 194 /* On some systems, this function is defined as an overloaded function: 195 extern "C++" { const void * std::memrchr (const void *, int, size_t); } 196 extern "C++" { void * std::memrchr (void *, int, size_t); } */ 197_GL_CXXALIAS_SYS_CAST2 (memrchr, 198 void *, (void const *, int, size_t), 199 void const *, (void const *, int, size_t)); 200# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \ 201 && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) 202_GL_CXXALIASWARN1 (memrchr, void *, (void *, int, size_t)); 203_GL_CXXALIASWARN1 (memrchr, void const *, (void const *, int, size_t)); 204# else 205_GL_CXXALIASWARN (memrchr); 206# endif 207#elif defined GNULIB_POSIXCHECK 208# undef memrchr 209# if HAVE_RAW_DECL_MEMRCHR 210_GL_WARN_ON_USE (memrchr, "memrchr is unportable - " 211 "use gnulib module memrchr for portability"); 212# endif 213#endif 214 215/* Find the first occurrence of C in S. More efficient than 216 memchr(S,C,N), at the expense of undefined behavior if C does not 217 occur within N bytes. */ 218#if @GNULIB_RAWMEMCHR@ 219# if ! @HAVE_RAWMEMCHR@ 220_GL_FUNCDECL_SYS (rawmemchr, void *, (void const *__s, int __c_in) 221 _GL_ATTRIBUTE_PURE 222 _GL_ARG_NONNULL ((1))); 223# endif 224 /* On some systems, this function is defined as an overloaded function: 225 extern "C++" { const void * std::rawmemchr (const void *, int); } 226 extern "C++" { void * std::rawmemchr (void *, int); } */ 227_GL_CXXALIAS_SYS_CAST2 (rawmemchr, 228 void *, (void const *__s, int __c_in), 229 void const *, (void const *__s, int __c_in)); 230# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \ 231 && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) 232_GL_CXXALIASWARN1 (rawmemchr, void *, (void *__s, int __c_in)); 233_GL_CXXALIASWARN1 (rawmemchr, void const *, (void const *__s, int __c_in)); 234# else 235_GL_CXXALIASWARN (rawmemchr); 236# endif 237#elif defined GNULIB_POSIXCHECK 238# undef rawmemchr 239# if HAVE_RAW_DECL_RAWMEMCHR 240_GL_WARN_ON_USE (rawmemchr, "rawmemchr is unportable - " 241 "use gnulib module rawmemchr for portability"); 242# endif 243#endif 244 245/* Copy SRC to DST, returning the address of the terminating '\0' in DST. */ 246#if @GNULIB_STPCPY@ 247# if ! @HAVE_STPCPY@ 248_GL_FUNCDECL_SYS (stpcpy, char *, 249 (char *restrict __dst, char const *restrict __src) 250 _GL_ARG_NONNULL ((1, 2))); 251# endif 252_GL_CXXALIAS_SYS (stpcpy, char *, 253 (char *restrict __dst, char const *restrict __src)); 254_GL_CXXALIASWARN (stpcpy); 255#elif defined GNULIB_POSIXCHECK 256# undef stpcpy 257# if HAVE_RAW_DECL_STPCPY 258_GL_WARN_ON_USE (stpcpy, "stpcpy is unportable - " 259 "use gnulib module stpcpy for portability"); 260# endif 261#endif 262 263/* Copy no more than N bytes of SRC to DST, returning a pointer past the 264 last non-NUL byte written into DST. */ 265#if @GNULIB_STPNCPY@ 266# if @REPLACE_STPNCPY@ 267# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 268# undef stpncpy 269# define stpncpy rpl_stpncpy 270# endif 271_GL_FUNCDECL_RPL (stpncpy, char *, 272 (char *restrict __dst, char const *restrict __src, 273 size_t __n) 274 _GL_ARG_NONNULL ((1, 2))); 275_GL_CXXALIAS_RPL (stpncpy, char *, 276 (char *restrict __dst, char const *restrict __src, 277 size_t __n)); 278# else 279# if ! @HAVE_STPNCPY@ 280_GL_FUNCDECL_SYS (stpncpy, char *, 281 (char *restrict __dst, char const *restrict __src, 282 size_t __n) 283 _GL_ARG_NONNULL ((1, 2))); 284# endif 285_GL_CXXALIAS_SYS (stpncpy, char *, 286 (char *restrict __dst, char const *restrict __src, 287 size_t __n)); 288# endif 289_GL_CXXALIASWARN (stpncpy); 290#elif defined GNULIB_POSIXCHECK 291# undef stpncpy 292# if HAVE_RAW_DECL_STPNCPY 293_GL_WARN_ON_USE (stpncpy, "stpncpy is unportable - " 294 "use gnulib module stpncpy for portability"); 295# endif 296#endif 297 298#if defined GNULIB_POSIXCHECK 299/* strchr() does not work with multibyte strings if the locale encoding is 300 GB18030 and the character to be searched is a digit. */ 301# undef strchr 302/* Assume strchr is always declared. */ 303_GL_WARN_ON_USE (strchr, "strchr cannot work correctly on character strings " 304 "in some multibyte locales - " 305 "use mbschr if you care about internationalization"); 306#endif 307 308/* Find the first occurrence of C in S or the final NUL byte. */ 309#if @GNULIB_STRCHRNUL@ 310# if @REPLACE_STRCHRNUL@ 311# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 312# define strchrnul rpl_strchrnul 313# endif 314_GL_FUNCDECL_RPL (strchrnul, char *, (const char *__s, int __c_in) 315 _GL_ATTRIBUTE_PURE 316 _GL_ARG_NONNULL ((1))); 317_GL_CXXALIAS_RPL (strchrnul, char *, 318 (const char *str, int ch)); 319# else 320# if ! @HAVE_STRCHRNUL@ 321_GL_FUNCDECL_SYS (strchrnul, char *, (char const *__s, int __c_in) 322 _GL_ATTRIBUTE_PURE 323 _GL_ARG_NONNULL ((1))); 324# endif 325 /* On some systems, this function is defined as an overloaded function: 326 extern "C++" { const char * std::strchrnul (const char *, int); } 327 extern "C++" { char * std::strchrnul (char *, int); } */ 328_GL_CXXALIAS_SYS_CAST2 (strchrnul, 329 char *, (char const *__s, int __c_in), 330 char const *, (char const *__s, int __c_in)); 331# endif 332# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \ 333 && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) 334_GL_CXXALIASWARN1 (strchrnul, char *, (char *__s, int __c_in)); 335_GL_CXXALIASWARN1 (strchrnul, char const *, (char const *__s, int __c_in)); 336# else 337_GL_CXXALIASWARN (strchrnul); 338# endif 339#elif defined GNULIB_POSIXCHECK 340# undef strchrnul 341# if HAVE_RAW_DECL_STRCHRNUL 342_GL_WARN_ON_USE (strchrnul, "strchrnul is unportable - " 343 "use gnulib module strchrnul for portability"); 344# endif 345#endif 346 347/* Duplicate S, returning an identical malloc'd string. */ 348#if @GNULIB_STRDUP@ 349# if @REPLACE_STRDUP@ 350# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 351# undef strdup 352# define strdup rpl_strdup 353# endif 354_GL_FUNCDECL_RPL (strdup, char *, (char const *__s) _GL_ARG_NONNULL ((1))); 355_GL_CXXALIAS_RPL (strdup, char *, (char const *__s)); 356# else 357# if defined __cplusplus && defined GNULIB_NAMESPACE && defined strdup 358 /* strdup exists as a function and as a macro. Get rid of the macro. */ 359# undef strdup 360# endif 361# if !(@HAVE_DECL_STRDUP@ || defined strdup) 362_GL_FUNCDECL_SYS (strdup, char *, (char const *__s) _GL_ARG_NONNULL ((1))); 363# endif 364_GL_CXXALIAS_SYS (strdup, char *, (char const *__s)); 365# endif 366_GL_CXXALIASWARN (strdup); 367#elif defined GNULIB_POSIXCHECK 368# undef strdup 369# if HAVE_RAW_DECL_STRDUP 370_GL_WARN_ON_USE (strdup, "strdup is unportable - " 371 "use gnulib module strdup for portability"); 372# endif 373#endif 374 375/* Append no more than N characters from SRC onto DEST. */ 376#if @GNULIB_STRNCAT@ 377# if @REPLACE_STRNCAT@ 378# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 379# undef strncat 380# define strncat rpl_strncat 381# endif 382_GL_FUNCDECL_RPL (strncat, char *, (char *dest, const char *src, size_t n) 383 _GL_ARG_NONNULL ((1, 2))); 384_GL_CXXALIAS_RPL (strncat, char *, (char *dest, const char *src, size_t n)); 385# else 386_GL_CXXALIAS_SYS (strncat, char *, (char *dest, const char *src, size_t n)); 387# endif 388_GL_CXXALIASWARN (strncat); 389#elif defined GNULIB_POSIXCHECK 390# undef strncat 391# if HAVE_RAW_DECL_STRNCAT 392_GL_WARN_ON_USE (strncat, "strncat is unportable - " 393 "use gnulib module strncat for portability"); 394# endif 395#endif 396 397/* Return a newly allocated copy of at most N bytes of STRING. */ 398#if @GNULIB_STRNDUP@ 399# if @REPLACE_STRNDUP@ 400# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 401# undef strndup 402# define strndup rpl_strndup 403# endif 404_GL_FUNCDECL_RPL (strndup, char *, (char const *__string, size_t __n) 405 _GL_ARG_NONNULL ((1))); 406_GL_CXXALIAS_RPL (strndup, char *, (char const *__string, size_t __n)); 407# else 408# if ! @HAVE_DECL_STRNDUP@ 409_GL_FUNCDECL_SYS (strndup, char *, (char const *__string, size_t __n) 410 _GL_ARG_NONNULL ((1))); 411# endif 412_GL_CXXALIAS_SYS (strndup, char *, (char const *__string, size_t __n)); 413# endif 414_GL_CXXALIASWARN (strndup); 415#elif defined GNULIB_POSIXCHECK 416# undef strndup 417# if HAVE_RAW_DECL_STRNDUP 418_GL_WARN_ON_USE (strndup, "strndup is unportable - " 419 "use gnulib module strndup for portability"); 420# endif 421#endif 422 423/* Find the length (number of bytes) of STRING, but scan at most 424 MAXLEN bytes. If no '\0' terminator is found in that many bytes, 425 return MAXLEN. */ 426#if @GNULIB_STRNLEN@ 427# if @REPLACE_STRNLEN@ 428# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 429# undef strnlen 430# define strnlen rpl_strnlen 431# endif 432_GL_FUNCDECL_RPL (strnlen, size_t, (char const *__string, size_t __maxlen) 433 _GL_ATTRIBUTE_PURE 434 _GL_ARG_NONNULL ((1))); 435_GL_CXXALIAS_RPL (strnlen, size_t, (char const *__string, size_t __maxlen)); 436# else 437# if ! @HAVE_DECL_STRNLEN@ 438_GL_FUNCDECL_SYS (strnlen, size_t, (char const *__string, size_t __maxlen) 439 _GL_ATTRIBUTE_PURE 440 _GL_ARG_NONNULL ((1))); 441# endif 442_GL_CXXALIAS_SYS (strnlen, size_t, (char const *__string, size_t __maxlen)); 443# endif 444_GL_CXXALIASWARN (strnlen); 445#elif defined GNULIB_POSIXCHECK 446# undef strnlen 447# if HAVE_RAW_DECL_STRNLEN 448_GL_WARN_ON_USE (strnlen, "strnlen is unportable - " 449 "use gnulib module strnlen for portability"); 450# endif 451#endif 452 453#if defined GNULIB_POSIXCHECK 454/* strcspn() assumes the second argument is a list of single-byte characters. 455 Even in this simple case, it does not work with multibyte strings if the 456 locale encoding is GB18030 and one of the characters to be searched is a 457 digit. */ 458# undef strcspn 459/* Assume strcspn is always declared. */ 460_GL_WARN_ON_USE (strcspn, "strcspn cannot work correctly on character strings " 461 "in multibyte locales - " 462 "use mbscspn if you care about internationalization"); 463#endif 464 465/* Find the first occurrence in S of any character in ACCEPT. */ 466#if @GNULIB_STRPBRK@ 467# if ! @HAVE_STRPBRK@ 468_GL_FUNCDECL_SYS (strpbrk, char *, (char const *__s, char const *__accept) 469 _GL_ATTRIBUTE_PURE 470 _GL_ARG_NONNULL ((1, 2))); 471# endif 472 /* On some systems, this function is defined as an overloaded function: 473 extern "C" { const char * strpbrk (const char *, const char *); } 474 extern "C++" { char * strpbrk (char *, const char *); } */ 475_GL_CXXALIAS_SYS_CAST2 (strpbrk, 476 char *, (char const *__s, char const *__accept), 477 const char *, (char const *__s, char const *__accept)); 478# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \ 479 && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) 480_GL_CXXALIASWARN1 (strpbrk, char *, (char *__s, char const *__accept)); 481_GL_CXXALIASWARN1 (strpbrk, char const *, 482 (char const *__s, char const *__accept)); 483# else 484_GL_CXXALIASWARN (strpbrk); 485# endif 486# if defined GNULIB_POSIXCHECK 487/* strpbrk() assumes the second argument is a list of single-byte characters. 488 Even in this simple case, it does not work with multibyte strings if the 489 locale encoding is GB18030 and one of the characters to be searched is a 490 digit. */ 491# undef strpbrk 492_GL_WARN_ON_USE (strpbrk, "strpbrk cannot work correctly on character strings " 493 "in multibyte locales - " 494 "use mbspbrk if you care about internationalization"); 495# endif 496#elif defined GNULIB_POSIXCHECK 497# undef strpbrk 498# if HAVE_RAW_DECL_STRPBRK 499_GL_WARN_ON_USE (strpbrk, "strpbrk is unportable - " 500 "use gnulib module strpbrk for portability"); 501# endif 502#endif 503 504#if defined GNULIB_POSIXCHECK 505/* strspn() assumes the second argument is a list of single-byte characters. 506 Even in this simple case, it cannot work with multibyte strings. */ 507# undef strspn 508/* Assume strspn is always declared. */ 509_GL_WARN_ON_USE (strspn, "strspn cannot work correctly on character strings " 510 "in multibyte locales - " 511 "use mbsspn if you care about internationalization"); 512#endif 513 514#if defined GNULIB_POSIXCHECK 515/* strrchr() does not work with multibyte strings if the locale encoding is 516 GB18030 and the character to be searched is a digit. */ 517# undef strrchr 518/* Assume strrchr is always declared. */ 519_GL_WARN_ON_USE (strrchr, "strrchr cannot work correctly on character strings " 520 "in some multibyte locales - " 521 "use mbsrchr if you care about internationalization"); 522#endif 523 524/* Search the next delimiter (char listed in DELIM) starting at *STRINGP. 525 If one is found, overwrite it with a NUL, and advance *STRINGP 526 to point to the next char after it. Otherwise, set *STRINGP to NULL. 527 If *STRINGP was already NULL, nothing happens. 528 Return the old value of *STRINGP. 529 530 This is a variant of strtok() that is multithread-safe and supports 531 empty fields. 532 533 Caveat: It modifies the original string. 534 Caveat: These functions cannot be used on constant strings. 535 Caveat: The identity of the delimiting character is lost. 536 Caveat: It doesn't work with multibyte strings unless all of the delimiter 537 characters are ASCII characters < 0x30. 538 539 See also strtok_r(). */ 540#if @GNULIB_STRSEP@ 541# if ! @HAVE_STRSEP@ 542_GL_FUNCDECL_SYS (strsep, char *, 543 (char **restrict __stringp, char const *restrict __delim) 544 _GL_ARG_NONNULL ((1, 2))); 545# endif 546_GL_CXXALIAS_SYS (strsep, char *, 547 (char **restrict __stringp, char const *restrict __delim)); 548_GL_CXXALIASWARN (strsep); 549# if defined GNULIB_POSIXCHECK 550# undef strsep 551_GL_WARN_ON_USE (strsep, "strsep cannot work correctly on character strings " 552 "in multibyte locales - " 553 "use mbssep if you care about internationalization"); 554# endif 555#elif defined GNULIB_POSIXCHECK 556# undef strsep 557# if HAVE_RAW_DECL_STRSEP 558_GL_WARN_ON_USE (strsep, "strsep is unportable - " 559 "use gnulib module strsep for portability"); 560# endif 561#endif 562 563#if @GNULIB_STRSTR@ 564# if @REPLACE_STRSTR@ 565# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 566# define strstr rpl_strstr 567# endif 568_GL_FUNCDECL_RPL (strstr, char *, (const char *haystack, const char *needle) 569 _GL_ATTRIBUTE_PURE 570 _GL_ARG_NONNULL ((1, 2))); 571_GL_CXXALIAS_RPL (strstr, char *, (const char *haystack, const char *needle)); 572# else 573 /* On some systems, this function is defined as an overloaded function: 574 extern "C++" { const char * strstr (const char *, const char *); } 575 extern "C++" { char * strstr (char *, const char *); } */ 576_GL_CXXALIAS_SYS_CAST2 (strstr, 577 char *, (const char *haystack, const char *needle), 578 const char *, (const char *haystack, const char *needle)); 579# endif 580# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \ 581 && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) 582_GL_CXXALIASWARN1 (strstr, char *, (char *haystack, const char *needle)); 583_GL_CXXALIASWARN1 (strstr, const char *, 584 (const char *haystack, const char *needle)); 585# else 586_GL_CXXALIASWARN (strstr); 587# endif 588#elif defined GNULIB_POSIXCHECK 589/* strstr() does not work with multibyte strings if the locale encoding is 590 different from UTF-8: 591 POSIX says that it operates on "strings", and "string" in POSIX is defined 592 as a sequence of bytes, not of characters. */ 593# undef strstr 594/* Assume strstr is always declared. */ 595_GL_WARN_ON_USE (strstr, "strstr is quadratic on many systems, and cannot " 596 "work correctly on character strings in most " 597 "multibyte locales - " 598 "use mbsstr if you care about internationalization, " 599 "or use strstr if you care about speed"); 600#endif 601 602/* Find the first occurrence of NEEDLE in HAYSTACK, using case-insensitive 603 comparison. */ 604#if @GNULIB_STRCASESTR@ 605# if @REPLACE_STRCASESTR@ 606# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 607# define strcasestr rpl_strcasestr 608# endif 609_GL_FUNCDECL_RPL (strcasestr, char *, 610 (const char *haystack, const char *needle) 611 _GL_ATTRIBUTE_PURE 612 _GL_ARG_NONNULL ((1, 2))); 613_GL_CXXALIAS_RPL (strcasestr, char *, 614 (const char *haystack, const char *needle)); 615# else 616# if ! @HAVE_STRCASESTR@ 617_GL_FUNCDECL_SYS (strcasestr, char *, 618 (const char *haystack, const char *needle) 619 _GL_ATTRIBUTE_PURE 620 _GL_ARG_NONNULL ((1, 2))); 621# endif 622 /* On some systems, this function is defined as an overloaded function: 623 extern "C++" { const char * strcasestr (const char *, const char *); } 624 extern "C++" { char * strcasestr (char *, const char *); } */ 625_GL_CXXALIAS_SYS_CAST2 (strcasestr, 626 char *, (const char *haystack, const char *needle), 627 const char *, (const char *haystack, const char *needle)); 628# endif 629# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \ 630 && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) 631_GL_CXXALIASWARN1 (strcasestr, char *, (char *haystack, const char *needle)); 632_GL_CXXALIASWARN1 (strcasestr, const char *, 633 (const char *haystack, const char *needle)); 634# else 635_GL_CXXALIASWARN (strcasestr); 636# endif 637#elif defined GNULIB_POSIXCHECK 638/* strcasestr() does not work with multibyte strings: 639 It is a glibc extension, and glibc implements it only for unibyte 640 locales. */ 641# undef strcasestr 642# if HAVE_RAW_DECL_STRCASESTR 643_GL_WARN_ON_USE (strcasestr, "strcasestr does work correctly on character " 644 "strings in multibyte locales - " 645 "use mbscasestr if you care about " 646 "internationalization, or use c-strcasestr if you want " 647 "a locale independent function"); 648# endif 649#endif 650 651/* Parse S into tokens separated by characters in DELIM. 652 If S is NULL, the saved pointer in SAVE_PTR is used as 653 the next starting point. For example: 654 char s[] = "-abc-=-def"; 655 char *sp; 656 x = strtok_r(s, "-", &sp); // x = "abc", sp = "=-def" 657 x = strtok_r(NULL, "-=", &sp); // x = "def", sp = NULL 658 x = strtok_r(NULL, "=", &sp); // x = NULL 659 // s = "abc\0-def\0" 660 661 This is a variant of strtok() that is multithread-safe. 662 663 For the POSIX documentation for this function, see: 664 http://www.opengroup.org/susv3xsh/strtok.html 665 666 Caveat: It modifies the original string. 667 Caveat: These functions cannot be used on constant strings. 668 Caveat: The identity of the delimiting character is lost. 669 Caveat: It doesn't work with multibyte strings unless all of the delimiter 670 characters are ASCII characters < 0x30. 671 672 See also strsep(). */ 673#if @GNULIB_STRTOK_R@ 674# if @REPLACE_STRTOK_R@ 675# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 676# undef strtok_r 677# define strtok_r rpl_strtok_r 678# endif 679_GL_FUNCDECL_RPL (strtok_r, char *, 680 (char *restrict s, char const *restrict delim, 681 char **restrict save_ptr) 682 _GL_ARG_NONNULL ((2, 3))); 683_GL_CXXALIAS_RPL (strtok_r, char *, 684 (char *restrict s, char const *restrict delim, 685 char **restrict save_ptr)); 686# else 687# if @UNDEFINE_STRTOK_R@ || defined GNULIB_POSIXCHECK 688# undef strtok_r 689# endif 690# if ! @HAVE_DECL_STRTOK_R@ 691_GL_FUNCDECL_SYS (strtok_r, char *, 692 (char *restrict s, char const *restrict delim, 693 char **restrict save_ptr) 694 _GL_ARG_NONNULL ((2, 3))); 695# endif 696_GL_CXXALIAS_SYS (strtok_r, char *, 697 (char *restrict s, char const *restrict delim, 698 char **restrict save_ptr)); 699# endif 700_GL_CXXALIASWARN (strtok_r); 701# if defined GNULIB_POSIXCHECK 702_GL_WARN_ON_USE (strtok_r, "strtok_r cannot work correctly on character " 703 "strings in multibyte locales - " 704 "use mbstok_r if you care about internationalization"); 705# endif 706#elif defined GNULIB_POSIXCHECK 707# undef strtok_r 708# if HAVE_RAW_DECL_STRTOK_R 709_GL_WARN_ON_USE (strtok_r, "strtok_r is unportable - " 710 "use gnulib module strtok_r for portability"); 711# endif 712#endif 713 714 715/* The following functions are not specified by POSIX. They are gnulib 716 extensions. */ 717 718#if @GNULIB_MBSLEN@ 719/* Return the number of multibyte characters in the character string STRING. 720 This considers multibyte characters, unlike strlen, which counts bytes. */ 721# ifdef __MirBSD__ /* MirBSD defines mbslen as a macro. Override it. */ 722# undef mbslen 723# endif 724# if @HAVE_MBSLEN@ /* AIX, OSF/1, MirBSD define mbslen already in libc. */ 725# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 726# define mbslen rpl_mbslen 727# endif 728_GL_FUNCDECL_RPL (mbslen, size_t, (const char *string) _GL_ARG_NONNULL ((1))); 729_GL_CXXALIAS_RPL (mbslen, size_t, (const char *string)); 730# else 731_GL_FUNCDECL_SYS (mbslen, size_t, (const char *string) _GL_ARG_NONNULL ((1))); 732_GL_CXXALIAS_SYS (mbslen, size_t, (const char *string)); 733# endif 734_GL_CXXALIASWARN (mbslen); 735#endif 736 737#if @GNULIB_MBSNLEN@ 738/* Return the number of multibyte characters in the character string starting 739 at STRING and ending at STRING + LEN. */ 740_GL_EXTERN_C size_t mbsnlen (const char *string, size_t len) 741 _GL_ARG_NONNULL ((1)); 742#endif 743 744#if @GNULIB_MBSCHR@ 745/* Locate the first single-byte character C in the character string STRING, 746 and return a pointer to it. Return NULL if C is not found in STRING. 747 Unlike strchr(), this function works correctly in multibyte locales with 748 encodings such as GB18030. */ 749# if defined __hpux 750# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 751# define mbschr rpl_mbschr /* avoid collision with HP-UX function */ 752# endif 753_GL_FUNCDECL_RPL (mbschr, char *, (const char *string, int c) 754 _GL_ARG_NONNULL ((1))); 755_GL_CXXALIAS_RPL (mbschr, char *, (const char *string, int c)); 756# else 757_GL_FUNCDECL_SYS (mbschr, char *, (const char *string, int c) 758 _GL_ARG_NONNULL ((1))); 759_GL_CXXALIAS_SYS (mbschr, char *, (const char *string, int c)); 760# endif 761_GL_CXXALIASWARN (mbschr); 762#endif 763 764#if @GNULIB_MBSRCHR@ 765/* Locate the last single-byte character C in the character string STRING, 766 and return a pointer to it. Return NULL if C is not found in STRING. 767 Unlike strrchr(), this function works correctly in multibyte locales with 768 encodings such as GB18030. */ 769# if defined __hpux || defined __INTERIX 770# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 771# define mbsrchr rpl_mbsrchr /* avoid collision with system function */ 772# endif 773_GL_FUNCDECL_RPL (mbsrchr, char *, (const char *string, int c) 774 _GL_ARG_NONNULL ((1))); 775_GL_CXXALIAS_RPL (mbsrchr, char *, (const char *string, int c)); 776# else 777_GL_FUNCDECL_SYS (mbsrchr, char *, (const char *string, int c) 778 _GL_ARG_NONNULL ((1))); 779_GL_CXXALIAS_SYS (mbsrchr, char *, (const char *string, int c)); 780# endif 781_GL_CXXALIASWARN (mbsrchr); 782#endif 783 784#if @GNULIB_MBSSTR@ 785/* Find the first occurrence of the character string NEEDLE in the character 786 string HAYSTACK. Return NULL if NEEDLE is not found in HAYSTACK. 787 Unlike strstr(), this function works correctly in multibyte locales with 788 encodings different from UTF-8. */ 789_GL_EXTERN_C char * mbsstr (const char *haystack, const char *needle) 790 _GL_ARG_NONNULL ((1, 2)); 791#endif 792 793#if @GNULIB_MBSCASECMP@ 794/* Compare the character strings S1 and S2, ignoring case, returning less than, 795 equal to or greater than zero if S1 is lexicographically less than, equal to 796 or greater than S2. 797 Note: This function may, in multibyte locales, return 0 for strings of 798 different lengths! 799 Unlike strcasecmp(), this function works correctly in multibyte locales. */ 800_GL_EXTERN_C int mbscasecmp (const char *s1, const char *s2) 801 _GL_ARG_NONNULL ((1, 2)); 802#endif 803 804#if @GNULIB_MBSNCASECMP@ 805/* Compare the initial segment of the character string S1 consisting of at most 806 N characters with the initial segment of the character string S2 consisting 807 of at most N characters, ignoring case, returning less than, equal to or 808 greater than zero if the initial segment of S1 is lexicographically less 809 than, equal to or greater than the initial segment of S2. 810 Note: This function may, in multibyte locales, return 0 for initial segments 811 of different lengths! 812 Unlike strncasecmp(), this function works correctly in multibyte locales. 813 But beware that N is not a byte count but a character count! */ 814_GL_EXTERN_C int mbsncasecmp (const char *s1, const char *s2, size_t n) 815 _GL_ARG_NONNULL ((1, 2)); 816#endif 817 818#if @GNULIB_MBSPCASECMP@ 819/* Compare the initial segment of the character string STRING consisting of 820 at most mbslen (PREFIX) characters with the character string PREFIX, 821 ignoring case. If the two match, return a pointer to the first byte 822 after this prefix in STRING. Otherwise, return NULL. 823 Note: This function may, in multibyte locales, return non-NULL if STRING 824 is of smaller length than PREFIX! 825 Unlike strncasecmp(), this function works correctly in multibyte 826 locales. */ 827_GL_EXTERN_C char * mbspcasecmp (const char *string, const char *prefix) 828 _GL_ARG_NONNULL ((1, 2)); 829#endif 830 831#if @GNULIB_MBSCASESTR@ 832/* Find the first occurrence of the character string NEEDLE in the character 833 string HAYSTACK, using case-insensitive comparison. 834 Note: This function may, in multibyte locales, return success even if 835 strlen (haystack) < strlen (needle) ! 836 Unlike strcasestr(), this function works correctly in multibyte locales. */ 837_GL_EXTERN_C char * mbscasestr (const char *haystack, const char *needle) 838 _GL_ARG_NONNULL ((1, 2)); 839#endif 840 841#if @GNULIB_MBSCSPN@ 842/* Find the first occurrence in the character string STRING of any character 843 in the character string ACCEPT. Return the number of bytes from the 844 beginning of the string to this occurrence, or to the end of the string 845 if none exists. 846 Unlike strcspn(), this function works correctly in multibyte locales. */ 847_GL_EXTERN_C size_t mbscspn (const char *string, const char *accept) 848 _GL_ARG_NONNULL ((1, 2)); 849#endif 850 851#if @GNULIB_MBSPBRK@ 852/* Find the first occurrence in the character string STRING of any character 853 in the character string ACCEPT. Return the pointer to it, or NULL if none 854 exists. 855 Unlike strpbrk(), this function works correctly in multibyte locales. */ 856# if defined __hpux 857# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 858# define mbspbrk rpl_mbspbrk /* avoid collision with HP-UX function */ 859# endif 860_GL_FUNCDECL_RPL (mbspbrk, char *, (const char *string, const char *accept) 861 _GL_ARG_NONNULL ((1, 2))); 862_GL_CXXALIAS_RPL (mbspbrk, char *, (const char *string, const char *accept)); 863# else 864_GL_FUNCDECL_SYS (mbspbrk, char *, (const char *string, const char *accept) 865 _GL_ARG_NONNULL ((1, 2))); 866_GL_CXXALIAS_SYS (mbspbrk, char *, (const char *string, const char *accept)); 867# endif 868_GL_CXXALIASWARN (mbspbrk); 869#endif 870 871#if @GNULIB_MBSSPN@ 872/* Find the first occurrence in the character string STRING of any character 873 not in the character string REJECT. Return the number of bytes from the 874 beginning of the string to this occurrence, or to the end of the string 875 if none exists. 876 Unlike strspn(), this function works correctly in multibyte locales. */ 877_GL_EXTERN_C size_t mbsspn (const char *string, const char *reject) 878 _GL_ARG_NONNULL ((1, 2)); 879#endif 880 881#if @GNULIB_MBSSEP@ 882/* Search the next delimiter (multibyte character listed in the character 883 string DELIM) starting at the character string *STRINGP. 884 If one is found, overwrite it with a NUL, and advance *STRINGP to point 885 to the next multibyte character after it. Otherwise, set *STRINGP to NULL. 886 If *STRINGP was already NULL, nothing happens. 887 Return the old value of *STRINGP. 888 889 This is a variant of mbstok_r() that supports empty fields. 890 891 Caveat: It modifies the original string. 892 Caveat: These functions cannot be used on constant strings. 893 Caveat: The identity of the delimiting character is lost. 894 895 See also mbstok_r(). */ 896_GL_EXTERN_C char * mbssep (char **stringp, const char *delim) 897 _GL_ARG_NONNULL ((1, 2)); 898#endif 899 900#if @GNULIB_MBSTOK_R@ 901/* Parse the character string STRING into tokens separated by characters in 902 the character string DELIM. 903 If STRING is NULL, the saved pointer in SAVE_PTR is used as 904 the next starting point. For example: 905 char s[] = "-abc-=-def"; 906 char *sp; 907 x = mbstok_r(s, "-", &sp); // x = "abc", sp = "=-def" 908 x = mbstok_r(NULL, "-=", &sp); // x = "def", sp = NULL 909 x = mbstok_r(NULL, "=", &sp); // x = NULL 910 // s = "abc\0-def\0" 911 912 Caveat: It modifies the original string. 913 Caveat: These functions cannot be used on constant strings. 914 Caveat: The identity of the delimiting character is lost. 915 916 See also mbssep(). */ 917_GL_EXTERN_C char * mbstok_r (char *string, const char *delim, char **save_ptr) 918 _GL_ARG_NONNULL ((2, 3)); 919#endif 920 921/* Map any int, typically from errno, into an error message. */ 922#if @GNULIB_STRERROR@ 923# if @REPLACE_STRERROR@ 924# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 925# undef strerror 926# define strerror rpl_strerror 927# endif 928_GL_FUNCDECL_RPL (strerror, char *, (int)); 929_GL_CXXALIAS_RPL (strerror, char *, (int)); 930# else 931_GL_CXXALIAS_SYS (strerror, char *, (int)); 932# endif 933_GL_CXXALIASWARN (strerror); 934#elif defined GNULIB_POSIXCHECK 935# undef strerror 936/* Assume strerror is always declared. */ 937_GL_WARN_ON_USE (strerror, "strerror is unportable - " 938 "use gnulib module strerror to guarantee non-NULL result"); 939#endif 940 941/* Map any int, typically from errno, into an error message. Multithread-safe. 942 Uses the POSIX declaration, not the glibc declaration. */ 943#if @GNULIB_STRERROR_R@ 944# if @REPLACE_STRERROR_R@ 945# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 946# undef strerror_r 947# define strerror_r rpl_strerror_r 948# endif 949_GL_FUNCDECL_RPL (strerror_r, int, (int errnum, char *buf, size_t buflen) 950 _GL_ARG_NONNULL ((2))); 951_GL_CXXALIAS_RPL (strerror_r, int, (int errnum, char *buf, size_t buflen)); 952# else 953# if !@HAVE_DECL_STRERROR_R@ 954_GL_FUNCDECL_SYS (strerror_r, int, (int errnum, char *buf, size_t buflen) 955 _GL_ARG_NONNULL ((2))); 956# endif 957_GL_CXXALIAS_SYS (strerror_r, int, (int errnum, char *buf, size_t buflen)); 958# endif 959# if @HAVE_DECL_STRERROR_R@ 960_GL_CXXALIASWARN (strerror_r); 961# endif 962#elif defined GNULIB_POSIXCHECK 963# undef strerror_r 964# if HAVE_RAW_DECL_STRERROR_R 965_GL_WARN_ON_USE (strerror_r, "strerror_r is unportable - " 966 "use gnulib module strerror_r-posix for portability"); 967# endif 968#endif 969 970#if @GNULIB_STRSIGNAL@ 971# if @REPLACE_STRSIGNAL@ 972# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 973# define strsignal rpl_strsignal 974# endif 975_GL_FUNCDECL_RPL (strsignal, char *, (int __sig)); 976_GL_CXXALIAS_RPL (strsignal, char *, (int __sig)); 977# else 978# if ! @HAVE_DECL_STRSIGNAL@ 979_GL_FUNCDECL_SYS (strsignal, char *, (int __sig)); 980# endif 981/* Need to cast, because on Cygwin 1.5.x systems, the return type is 982 'const char *'. */ 983_GL_CXXALIAS_SYS_CAST (strsignal, char *, (int __sig)); 984# endif 985_GL_CXXALIASWARN (strsignal); 986#elif defined GNULIB_POSIXCHECK 987# undef strsignal 988# if HAVE_RAW_DECL_STRSIGNAL 989_GL_WARN_ON_USE (strsignal, "strsignal is unportable - " 990 "use gnulib module strsignal for portability"); 991# endif 992#endif 993 994#if @GNULIB_STRVERSCMP@ 995# if !@HAVE_STRVERSCMP@ 996_GL_FUNCDECL_SYS (strverscmp, int, (const char *, const char *) 997 _GL_ARG_NONNULL ((1, 2))); 998# endif 999_GL_CXXALIAS_SYS (strverscmp, int, (const char *, const char *)); 1000_GL_CXXALIASWARN (strverscmp); 1001#elif defined GNULIB_POSIXCHECK 1002# undef strverscmp 1003# if HAVE_RAW_DECL_STRVERSCMP 1004_GL_WARN_ON_USE (strverscmp, "strverscmp is unportable - " 1005 "use gnulib module strverscmp for portability"); 1006# endif 1007#endif 1008 1009 1010#endif /* _@GUARD_PREFIX@_STRING_H */ 1011#endif /* _@GUARD_PREFIX@_STRING_H */ 1012