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