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