1 /* Machine-independant string function optimizations. 2 Copyright (C) 1997-2003, 2004, 2007 Free Software Foundation, Inc. 3 This file is part of the GNU C Library. 4 Contributed by Ulrich Drepper <drepper (at) cygnus.com>, 1997. 5 6 The GNU C Library is free software; you can redistribute it and/or 7 modify it under the terms of the GNU Lesser General Public 8 License as published by the Free Software Foundation; either 9 version 2.1 of the License, or (at your option) any later version. 10 11 The GNU C Library is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 Lesser General Public License for more details. 15 16 You should have received a copy of the GNU Lesser General Public 17 License along with the GNU C Library; if not, write to the Free 18 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 19 02111-1307 USA. */ 20 21 #ifndef _STRING_H 22 # error "Never use <bits/string2.h> directly; include <string.h> instead." 23 #endif 24 25 #if !defined __NO_STRING_INLINES && !defined __BOUNDED_POINTERS__ 26 27 /* Unlike the definitions in the header <bits/string.h> the 28 definitions contained here are not optimized down to assembler 29 level. Those optimizations are not always a good idea since this 30 means the code size increases a lot. Instead the definitions here 31 optimize some functions in a way which do not dramatically 32 increase the code size and which do not use assembler. The main 33 trick is to use GCC's `__builtin_constant_p' function. 34 35 Every function XXX which has a defined version in 36 <bits/string.h> must be accompanied by a symbol _HAVE_STRING_ARCH_XXX 37 to make sure we don't get redefinitions. 38 39 We must use here macros instead of inline functions since the 40 trick won't work with the latter. */ 41 42 #ifndef __STRING_INLINE 43 # ifdef __cplusplus 44 # define __STRING_INLINE inline 45 # else 46 # define __STRING_INLINE __extern_inline 47 # endif 48 #endif 49 50 #if _STRING_ARCH_unaligned 51 /* If we can do unaligned memory accesses we must know the endianess. */ 52 # include <endian.h> 53 # include <bits/types.h> 54 55 # if __BYTE_ORDER == __LITTLE_ENDIAN 56 # define __STRING2_SMALL_GET16(src, idx) \ 57 (((__const unsigned char *) (__const char *) (src))[idx + 1] << 8 \ 58 | ((__const unsigned char *) (__const char *) (src))[idx]) 59 # define __STRING2_SMALL_GET32(src, idx) \ 60 (((((__const unsigned char *) (__const char *) (src))[idx + 3] << 8 \ 61 | ((__const unsigned char *) (__const char *) (src))[idx + 2]) << 8 \ 62 | ((__const unsigned char *) (__const char *) (src))[idx + 1]) << 8 \ 63 | ((__const unsigned char *) (__const char *) (src))[idx]) 64 # else 65 # define __STRING2_SMALL_GET16(src, idx) \ 66 (((__const unsigned char *) (__const char *) (src))[idx] << 8 \ 67 | ((__const unsigned char *) (__const char *) (src))[idx + 1]) 68 # define __STRING2_SMALL_GET32(src, idx) \ 69 (((((__const unsigned char *) (__const char *) (src))[idx] << 8 \ 70 | ((__const unsigned char *) (__const char *) (src))[idx + 1]) << 8 \ 71 | ((__const unsigned char *) (__const char *) (src))[idx + 2]) << 8 \ 72 | ((__const unsigned char *) (__const char *) (src))[idx + 3]) 73 # endif 74 #else 75 /* These are a few types we need for the optimizations if we cannot 76 use unaligned memory accesses. */ 77 # define __STRING2_COPY_TYPE(N) \ 78 typedef struct { unsigned char __arr[N]; } \ 79 __attribute__ ((__packed__)) __STRING2_COPY_ARR##N 80 __STRING2_COPY_TYPE (2); 81 __STRING2_COPY_TYPE (3); 82 __STRING2_COPY_TYPE (4); 83 __STRING2_COPY_TYPE (5); 84 __STRING2_COPY_TYPE (6); 85 __STRING2_COPY_TYPE (7); 86 __STRING2_COPY_TYPE (8); 87 # undef __STRING2_COPY_TYPE 88 #endif 89 90 /* Dereferencing a pointer arg to run sizeof on it fails for the void 91 pointer case, so we use this instead. 92 Note that __x is evaluated twice. */ 93 #define __string2_1bptr_p(__x) \ 94 ((size_t)(const void *)((__x) + 1) - (size_t)(const void *)(__x) == 1) 95 96 /* Set N bytes of S to C. */ 97 #if !defined _HAVE_STRING_ARCH_memset 98 # if !__GNUC_PREREQ (3, 0) 99 # if _STRING_ARCH_unaligned 100 # define memset(s, c, n) \ 101 (__extension__ (__builtin_constant_p (n) && (n) <= 16 \ 102 ? ((n) == 1 \ 103 ? __memset_1 (s, c) \ 104 : __memset_gc (s, c, n)) \ 105 : (__builtin_constant_p (c) && (c) == '\0' \ 106 ? ({ void *__s = (s); __bzero (__s, n); __s; }) \ 107 : memset (s, c, n)))) 108 109 # define __memset_1(s, c) ({ void *__s = (s); \ 110 *((__uint8_t *) __s) = (__uint8_t) c; __s; }) 111 112 # define __memset_gc(s, c, n) \ 113 ({ void *__s = (s); \ 114 union { \ 115 unsigned int __ui; \ 116 unsigned short int __usi; \ 117 unsigned char __uc; \ 118 } *__u = __s; \ 119 __uint8_t __c = (__uint8_t) (c); \ 120 \ 121 /* This `switch' statement will be removed at compile-time. */ \ 122 switch ((unsigned int) (n)) \ 123 { \ 124 case 15: \ 125 __u->__ui = __c * 0x01010101; \ 126 __u = __extension__ ((void *) __u + 4); \ 127 case 11: \ 128 __u->__ui = __c * 0x01010101; \ 129 __u = __extension__ ((void *) __u + 4); \ 130 case 7: \ 131 __u->__ui = __c * 0x01010101; \ 132 __u = __extension__ ((void *) __u + 4); \ 133 case 3: \ 134 __u->__usi = (unsigned short int) __c * 0x0101; \ 135 __u = __extension__ ((void *) __u + 2); \ 136 __u->__uc = (unsigned char) __c; \ 137 break; \ 138 \ 139 case 14: \ 140 __u->__ui = __c * 0x01010101; \ 141 __u = __extension__ ((void *) __u + 4); \ 142 case 10: \ 143 __u->__ui = __c * 0x01010101; \ 144 __u = __extension__ ((void *) __u + 4); \ 145 case 6: \ 146 __u->__ui = __c * 0x01010101; \ 147 __u = __extension__ ((void *) __u + 4); \ 148 case 2: \ 149 __u->__usi = (unsigned short int) __c * 0x0101; \ 150 break; \ 151 \ 152 case 13: \ 153 __u->__ui = __c * 0x01010101; \ 154 __u = __extension__ ((void *) __u + 4); \ 155 case 9: \ 156 __u->__ui = __c * 0x01010101; \ 157 __u = __extension__ ((void *) __u + 4); \ 158 case 5: \ 159 __u->__ui = __c * 0x01010101; \ 160 __u = __extension__ ((void *) __u + 4); \ 161 case 1: \ 162 __u->__uc = (unsigned char) __c; \ 163 break; \ 164 \ 165 case 16: \ 166 __u->__ui = __c * 0x01010101; \ 167 __u = __extension__ ((void *) __u + 4); \ 168 case 12: \ 169 __u->__ui = __c * 0x01010101; \ 170 __u = __extension__ ((void *) __u + 4); \ 171 case 8: \ 172 __u->__ui = __c * 0x01010101; \ 173 __u = __extension__ ((void *) __u + 4); \ 174 case 4: \ 175 __u->__ui = __c * 0x01010101; \ 176 case 0: \ 177 break; \ 178 } \ 179 \ 180 __s; }) 181 # else 182 # define memset(s, c, n) \ 183 (__extension__ (__builtin_constant_p (c) && (c) == '\0' \ 184 ? ({ void *__s = (s); __bzero (__s, n); __s; }) \ 185 : memset (s, c, n))) 186 # endif 187 # endif 188 189 /* GCC < 3.0 optimizes memset(s, 0, n) but not bzero(s, n). 190 The optimization is broken before EGCS 1.1. 191 GCC 3.0+ has __builtin_bzero as well, but at least till GCC 3.4 192 if it decides to call the library function, it calls memset 193 and not bzero. */ 194 # if __GNUC_PREREQ (2, 91) 195 # define __bzero(s, n) __builtin_memset (s, '\0', n) 196 # endif 197 198 #endif 199 200 201 /* Copy N bytes from SRC to DEST, returning pointer to byte following the 202 last copied. */ 203 #ifdef __USE_GNU 204 # if !defined _HAVE_STRING_ARCH_mempcpy || defined _FORCE_INLINES 205 # ifndef _HAVE_STRING_ARCH_mempcpy 206 # if __GNUC_PREREQ (3, 4) 207 # define __mempcpy(dest, src, n) __builtin_mempcpy (dest, src, n) 208 # elif __GNUC_PREREQ (3, 0) 209 # define __mempcpy(dest, src, n) \ 210 (__extension__ (__builtin_constant_p (src) && __builtin_constant_p (n) \ 211 && __string2_1bptr_p (src) && n <= 8 \ 212 ? __builtin_memcpy (dest, src, n) + (n) \ 213 : __mempcpy (dest, src, n))) 214 # else 215 # define __mempcpy(dest, src, n) \ 216 (__extension__ (__builtin_constant_p (src) && __builtin_constant_p (n) \ 217 && __string2_1bptr_p (src) && n <= 8 \ 218 ? __mempcpy_small (dest, __mempcpy_args (src), n) \ 219 : __mempcpy (dest, src, n))) 220 # endif 221 /* In glibc we use this function frequently but for namespace reasons 222 we have to use the name `__mempcpy'. */ 223 # define mempcpy(dest, src, n) __mempcpy (dest, src, n) 224 # endif 225 226 # if !__GNUC_PREREQ (3, 0) || defined _FORCE_INLINES 227 # if _STRING_ARCH_unaligned 228 # ifndef _FORCE_INLINES 229 # define __mempcpy_args(src) \ 230 ((__const char *) (src))[0], ((__const char *) (src))[2], \ 231 ((__const char *) (src))[4], ((__const char *) (src))[6], \ 232 __extension__ __STRING2_SMALL_GET16 (src, 0), \ 233 __extension__ __STRING2_SMALL_GET16 (src, 4), \ 234 __extension__ __STRING2_SMALL_GET32 (src, 0), \ 235 __extension__ __STRING2_SMALL_GET32 (src, 4) 236 # endif 237 __STRING_INLINE void *__mempcpy_small (void *, char, char, char, char, 238 __uint16_t, __uint16_t, __uint32_t, 239 __uint32_t, size_t); 240 __STRING_INLINE void * 241 __mempcpy_small (void *__dest1, 242 char __src0_1, char __src2_1, char __src4_1, char __src6_1, 243 __uint16_t __src0_2, __uint16_t __src4_2, 244 __uint32_t __src0_4, __uint32_t __src4_4, 245 size_t __srclen) 246 { 247 union { 248 __uint32_t __ui; 249 __uint16_t __usi; 250 unsigned char __uc; 251 unsigned char __c; 252 } *__u = __dest1; 253 switch ((unsigned int) __srclen) 254 { 255 case 1: 256 __u->__c = __src0_1; 257 __u = __extension__ ((void *) __u + 1); 258 break; 259 case 2: 260 __u->__usi = __src0_2; 261 __u = __extension__ ((void *) __u + 2); 262 break; 263 case 3: 264 __u->__usi = __src0_2; 265 __u = __extension__ ((void *) __u + 2); 266 __u->__c = __src2_1; 267 __u = __extension__ ((void *) __u + 1); 268 break; 269 case 4: 270 __u->__ui = __src0_4; 271 __u = __extension__ ((void *) __u + 4); 272 break; 273 case 5: 274 __u->__ui = __src0_4; 275 __u = __extension__ ((void *) __u + 4); 276 __u->__c = __src4_1; 277 __u = __extension__ ((void *) __u + 1); 278 break; 279 case 6: 280 __u->__ui = __src0_4; 281 __u = __extension__ ((void *) __u + 4); 282 __u->__usi = __src4_2; 283 __u = __extension__ ((void *) __u + 2); 284 break; 285 case 7: 286 __u->__ui = __src0_4; 287 __u = __extension__ ((void *) __u + 4); 288 __u->__usi = __src4_2; 289 __u = __extension__ ((void *) __u + 2); 290 __u->__c = __src6_1; 291 __u = __extension__ ((void *) __u + 1); 292 break; 293 case 8: 294 __u->__ui = __src0_4; 295 __u = __extension__ ((void *) __u + 4); 296 __u->__ui = __src4_4; 297 __u = __extension__ ((void *) __u + 4); 298 break; 299 } 300 return (void *) __u; 301 } 302 # else 303 # ifndef _FORCE_INLINES 304 # define __mempcpy_args(src) \ 305 ((__const char *) (src))[0], \ 306 __extension__ ((__STRING2_COPY_ARR2) \ 307 { { ((__const char *) (src))[0], ((__const char *) (src))[1] } }), \ 308 __extension__ ((__STRING2_COPY_ARR3) \ 309 { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 310 ((__const char *) (src))[2] } }), \ 311 __extension__ ((__STRING2_COPY_ARR4) \ 312 { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 313 ((__const char *) (src))[2], ((__const char *) (src))[3] } }), \ 314 __extension__ ((__STRING2_COPY_ARR5) \ 315 { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 316 ((__const char *) (src))[2], ((__const char *) (src))[3], \ 317 ((__const char *) (src))[4] } }), \ 318 __extension__ ((__STRING2_COPY_ARR6) \ 319 { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 320 ((__const char *) (src))[2], ((__const char *) (src))[3], \ 321 ((__const char *) (src))[4], ((__const char *) (src))[5] } }), \ 322 __extension__ ((__STRING2_COPY_ARR7) \ 323 { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 324 ((__const char *) (src))[2], ((__const char *) (src))[3], \ 325 ((__const char *) (src))[4], ((__const char *) (src))[5], \ 326 ((__const char *) (src))[6] } }), \ 327 __extension__ ((__STRING2_COPY_ARR8) \ 328 { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 329 ((__const char *) (src))[2], ((__const char *) (src))[3], \ 330 ((__const char *) (src))[4], ((__const char *) (src))[5], \ 331 ((__const char *) (src))[6], ((__const char *) (src))[7] } }) 332 # endif 333 __STRING_INLINE void *__mempcpy_small (void *, char, __STRING2_COPY_ARR2, 334 __STRING2_COPY_ARR3, 335 __STRING2_COPY_ARR4, 336 __STRING2_COPY_ARR5, 337 __STRING2_COPY_ARR6, 338 __STRING2_COPY_ARR7, 339 __STRING2_COPY_ARR8, size_t); 340 __STRING_INLINE void * 341 __mempcpy_small (void *__dest, char __src1, 342 __STRING2_COPY_ARR2 __src2, __STRING2_COPY_ARR3 __src3, 343 __STRING2_COPY_ARR4 __src4, __STRING2_COPY_ARR5 __src5, 344 __STRING2_COPY_ARR6 __src6, __STRING2_COPY_ARR7 __src7, 345 __STRING2_COPY_ARR8 __src8, size_t __srclen) 346 { 347 union { 348 char __c; 349 __STRING2_COPY_ARR2 __sca2; 350 __STRING2_COPY_ARR3 __sca3; 351 __STRING2_COPY_ARR4 __sca4; 352 __STRING2_COPY_ARR5 __sca5; 353 __STRING2_COPY_ARR6 __sca6; 354 __STRING2_COPY_ARR7 __sca7; 355 __STRING2_COPY_ARR8 __sca8; 356 } *__u = __dest; 357 switch ((unsigned int) __srclen) 358 { 359 case 1: 360 __u->__c = __src1; 361 break; 362 case 2: 363 __extension__ __u->__sca2 = __src2; 364 break; 365 case 3: 366 __extension__ __u->__sca3 = __src3; 367 break; 368 case 4: 369 __extension__ __u->__sca4 = __src4; 370 break; 371 case 5: 372 __extension__ __u->__sca5 = __src5; 373 break; 374 case 6: 375 __extension__ __u->__sca6 = __src6; 376 break; 377 case 7: 378 __extension__ __u->__sca7 = __src7; 379 break; 380 case 8: 381 __extension__ __u->__sca8 = __src8; 382 break; 383 } 384 return __extension__ ((void *) __u + __srclen); 385 } 386 # endif 387 # endif 388 # endif 389 #endif 390 391 392 /* Return pointer to C in S. */ 393 #ifndef _HAVE_STRING_ARCH_strchr 394 extern void *__rawmemchr (const void *__s, int __c); 395 # if __GNUC_PREREQ (3, 2) 396 # define strchr(s, c) \ 397 (__extension__ (__builtin_constant_p (c) && !__builtin_constant_p (s) \ 398 && (c) == '\0' \ 399 ? (char *) __rawmemchr (s, c) \ 400 : __builtin_strchr (s, c))) 401 # else 402 # define strchr(s, c) \ 403 (__extension__ (__builtin_constant_p (c) && (c) == '\0' \ 404 ? (char *) __rawmemchr (s, c) \ 405 : strchr (s, c))) 406 # endif 407 #endif 408 409 410 /* Copy SRC to DEST. */ 411 #if (!defined _HAVE_STRING_ARCH_strcpy && !__GNUC_PREREQ (3, 0)) \ 412 || defined _FORCE_INLINES 413 # if !defined _HAVE_STRING_ARCH_strcpy && !__GNUC_PREREQ (3, 0) 414 # define strcpy(dest, src) \ 415 (__extension__ (__builtin_constant_p (src) \ 416 ? (__string2_1bptr_p (src) && strlen (src) + 1 <= 8 \ 417 ? __strcpy_small (dest, __strcpy_args (src), \ 418 strlen (src) + 1) \ 419 : (char *) memcpy (dest, src, strlen (src) + 1)) \ 420 : strcpy (dest, src))) 421 # endif 422 423 # if _STRING_ARCH_unaligned 424 # ifndef _FORCE_INLINES 425 # define __strcpy_args(src) \ 426 __extension__ __STRING2_SMALL_GET16 (src, 0), \ 427 __extension__ __STRING2_SMALL_GET16 (src, 4), \ 428 __extension__ __STRING2_SMALL_GET32 (src, 0), \ 429 __extension__ __STRING2_SMALL_GET32 (src, 4) 430 # endif 431 __STRING_INLINE char *__strcpy_small (char *, __uint16_t, __uint16_t, 432 __uint32_t, __uint32_t, size_t); 433 __STRING_INLINE char * 434 __strcpy_small (char *__dest, 435 __uint16_t __src0_2, __uint16_t __src4_2, 436 __uint32_t __src0_4, __uint32_t __src4_4, 437 size_t __srclen) 438 { 439 union { 440 __uint32_t __ui; 441 __uint16_t __usi; 442 unsigned char __uc; 443 } *__u = (void *) __dest; 444 switch ((unsigned int) __srclen) 445 { 446 case 1: 447 __u->__uc = '\0'; 448 break; 449 case 2: 450 __u->__usi = __src0_2; 451 break; 452 case 3: 453 __u->__usi = __src0_2; 454 __u = __extension__ ((void *) __u + 2); 455 __u->__uc = '\0'; 456 break; 457 case 4: 458 __u->__ui = __src0_4; 459 break; 460 case 5: 461 __u->__ui = __src0_4; 462 __u = __extension__ ((void *) __u + 4); 463 __u->__uc = '\0'; 464 break; 465 case 6: 466 __u->__ui = __src0_4; 467 __u = __extension__ ((void *) __u + 4); 468 __u->__usi = __src4_2; 469 break; 470 case 7: 471 __u->__ui = __src0_4; 472 __u = __extension__ ((void *) __u + 4); 473 __u->__usi = __src4_2; 474 __u = __extension__ ((void *) __u + 2); 475 __u->__uc = '\0'; 476 break; 477 case 8: 478 __u->__ui = __src0_4; 479 __u = __extension__ ((void *) __u + 4); 480 __u->__ui = __src4_4; 481 break; 482 } 483 return __dest; 484 } 485 # else 486 # ifndef _FORCE_INLINES 487 # define __strcpy_args(src) \ 488 __extension__ ((__STRING2_COPY_ARR2) \ 489 { { ((__const char *) (src))[0], '\0' } }), \ 490 __extension__ ((__STRING2_COPY_ARR3) \ 491 { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 492 '\0' } }), \ 493 __extension__ ((__STRING2_COPY_ARR4) \ 494 { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 495 ((__const char *) (src))[2], '\0' } }), \ 496 __extension__ ((__STRING2_COPY_ARR5) \ 497 { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 498 ((__const char *) (src))[2], ((__const char *) (src))[3], \ 499 '\0' } }), \ 500 __extension__ ((__STRING2_COPY_ARR6) \ 501 { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 502 ((__const char *) (src))[2], ((__const char *) (src))[3], \ 503 ((__const char *) (src))[4], '\0' } }), \ 504 __extension__ ((__STRING2_COPY_ARR7) \ 505 { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 506 ((__const char *) (src))[2], ((__const char *) (src))[3], \ 507 ((__const char *) (src))[4], ((__const char *) (src))[5], \ 508 '\0' } }), \ 509 __extension__ ((__STRING2_COPY_ARR8) \ 510 { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 511 ((__const char *) (src))[2], ((__const char *) (src))[3], \ 512 ((__const char *) (src))[4], ((__const char *) (src))[5], \ 513 ((__const char *) (src))[6], '\0' } }) 514 # endif 515 __STRING_INLINE char *__strcpy_small (char *, __STRING2_COPY_ARR2, 516 __STRING2_COPY_ARR3, 517 __STRING2_COPY_ARR4, 518 __STRING2_COPY_ARR5, 519 __STRING2_COPY_ARR6, 520 __STRING2_COPY_ARR7, 521 __STRING2_COPY_ARR8, size_t); 522 __STRING_INLINE char * 523 __strcpy_small (char *__dest, 524 __STRING2_COPY_ARR2 __src2, __STRING2_COPY_ARR3 __src3, 525 __STRING2_COPY_ARR4 __src4, __STRING2_COPY_ARR5 __src5, 526 __STRING2_COPY_ARR6 __src6, __STRING2_COPY_ARR7 __src7, 527 __STRING2_COPY_ARR8 __src8, size_t __srclen) 528 { 529 union { 530 char __c; 531 __STRING2_COPY_ARR2 __sca2; 532 __STRING2_COPY_ARR3 __sca3; 533 __STRING2_COPY_ARR4 __sca4; 534 __STRING2_COPY_ARR5 __sca5; 535 __STRING2_COPY_ARR6 __sca6; 536 __STRING2_COPY_ARR7 __sca7; 537 __STRING2_COPY_ARR8 __sca8; 538 } *__u = (void *) __dest; 539 switch ((unsigned int) __srclen) 540 { 541 case 1: 542 __u->__c = '\0'; 543 break; 544 case 2: 545 __extension__ __u->__sca2 = __src2; 546 break; 547 case 3: 548 __extension__ __u->__sca3 = __src3; 549 break; 550 case 4: 551 __extension__ __u->__sca4 = __src4; 552 break; 553 case 5: 554 __extension__ __u->__sca5 = __src5; 555 break; 556 case 6: 557 __extension__ __u->__sca6 = __src6; 558 break; 559 case 7: 560 __extension__ __u->__sca7 = __src7; 561 break; 562 case 8: 563 __extension__ __u->__sca8 = __src8; 564 break; 565 } 566 return __dest; 567 } 568 # endif 569 #endif 570 571 572 /* Copy SRC to DEST, returning pointer to final NUL byte. */ 573 #ifdef __USE_GNU 574 # if !defined _HAVE_STRING_ARCH_stpcpy || defined _FORCE_INLINES 575 # ifndef _HAVE_STRING_ARCH_stpcpy 576 # if __GNUC_PREREQ (3, 4) 577 # define __stpcpy(dest, src) __builtin_stpcpy (dest, src) 578 # elif __GNUC_PREREQ (3, 0) 579 # define __stpcpy(dest, src) \ 580 (__extension__ (__builtin_constant_p (src) \ 581 ? (__string2_1bptr_p (src) && strlen (src) + 1 <= 8 \ 582 ? __builtin_strcpy (dest, src) + strlen (src) \ 583 : ((char *) (__mempcpy) (dest, src, strlen (src) + 1) \ 584 - 1)) \ 585 : __stpcpy (dest, src))) 586 # else 587 # define __stpcpy(dest, src) \ 588 (__extension__ (__builtin_constant_p (src) \ 589 ? (__string2_1bptr_p (src) && strlen (src) + 1 <= 8 \ 590 ? __stpcpy_small (dest, __stpcpy_args (src), \ 591 strlen (src) + 1) \ 592 : ((char *) (__mempcpy) (dest, src, strlen (src) + 1) \ 593 - 1)) \ 594 : __stpcpy (dest, src))) 595 # endif 596 /* In glibc we use this function frequently but for namespace reasons 597 we have to use the name `__stpcpy'. */ 598 # define stpcpy(dest, src) __stpcpy (dest, src) 599 # endif 600 601 # if !__GNUC_PREREQ (3, 0) || defined _FORCE_INLINES 602 # if _STRING_ARCH_unaligned 603 # ifndef _FORCE_INLINES 604 # define __stpcpy_args(src) \ 605 __extension__ __STRING2_SMALL_GET16 (src, 0), \ 606 __extension__ __STRING2_SMALL_GET16 (src, 4), \ 607 __extension__ __STRING2_SMALL_GET32 (src, 0), \ 608 __extension__ __STRING2_SMALL_GET32 (src, 4) 609 # endif 610 __STRING_INLINE char *__stpcpy_small (char *, __uint16_t, __uint16_t, 611 __uint32_t, __uint32_t, size_t); 612 __STRING_INLINE char * 613 __stpcpy_small (char *__dest, 614 __uint16_t __src0_2, __uint16_t __src4_2, 615 __uint32_t __src0_4, __uint32_t __src4_4, 616 size_t __srclen) 617 { 618 union { 619 unsigned int __ui; 620 unsigned short int __usi; 621 unsigned char __uc; 622 char __c; 623 } *__u = (void *) __dest; 624 switch ((unsigned int) __srclen) 625 { 626 case 1: 627 __u->__uc = '\0'; 628 break; 629 case 2: 630 __u->__usi = __src0_2; 631 __u = __extension__ ((void *) __u + 1); 632 break; 633 case 3: 634 __u->__usi = __src0_2; 635 __u = __extension__ ((void *) __u + 2); 636 __u->__uc = '\0'; 637 break; 638 case 4: 639 __u->__ui = __src0_4; 640 __u = __extension__ ((void *) __u + 3); 641 break; 642 case 5: 643 __u->__ui = __src0_4; 644 __u = __extension__ ((void *) __u + 4); 645 __u->__uc = '\0'; 646 break; 647 case 6: 648 __u->__ui = __src0_4; 649 __u = __extension__ ((void *) __u + 4); 650 __u->__usi = __src4_2; 651 __u = __extension__ ((void *) __u + 1); 652 break; 653 case 7: 654 __u->__ui = __src0_4; 655 __u = __extension__ ((void *) __u + 4); 656 __u->__usi = __src4_2; 657 __u = __extension__ ((void *) __u + 2); 658 __u->__uc = '\0'; 659 break; 660 case 8: 661 __u->__ui = __src0_4; 662 __u = __extension__ ((void *) __u + 4); 663 __u->__ui = __src4_4; 664 __u = __extension__ ((void *) __u + 3); 665 break; 666 } 667 return &__u->__c; 668 } 669 # else 670 # ifndef _FORCE_INLINES 671 # define __stpcpy_args(src) \ 672 __extension__ ((__STRING2_COPY_ARR2) \ 673 { { ((__const char *) (src))[0], '\0' } }), \ 674 __extension__ ((__STRING2_COPY_ARR3) \ 675 { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 676 '\0' } }), \ 677 __extension__ ((__STRING2_COPY_ARR4) \ 678 { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 679 ((__const char *) (src))[2], '\0' } }), \ 680 __extension__ ((__STRING2_COPY_ARR5) \ 681 { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 682 ((__const char *) (src))[2], ((__const char *) (src))[3], \ 683 '\0' } }), \ 684 __extension__ ((__STRING2_COPY_ARR6) \ 685 { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 686 ((__const char *) (src))[2], ((__const char *) (src))[3], \ 687 ((__const char *) (src))[4], '\0' } }), \ 688 __extension__ ((__STRING2_COPY_ARR7) \ 689 { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 690 ((__const char *) (src))[2], ((__const char *) (src))[3], \ 691 ((__const char *) (src))[4], ((__const char *) (src))[5], \ 692 '\0' } }), \ 693 __extension__ ((__STRING2_COPY_ARR8) \ 694 { { ((__const char *) (src))[0], ((__const char *) (src))[1], \ 695 ((__const char *) (src))[2], ((__const char *) (src))[3], \ 696 ((__const char *) (src))[4], ((__const char *) (src))[5], \ 697 ((__const char *) (src))[6], '\0' } }) 698 # endif 699 __STRING_INLINE char *__stpcpy_small (char *, __STRING2_COPY_ARR2, 700 __STRING2_COPY_ARR3, 701 __STRING2_COPY_ARR4, 702 __STRING2_COPY_ARR5, 703 __STRING2_COPY_ARR6, 704 __STRING2_COPY_ARR7, 705 __STRING2_COPY_ARR8, size_t); 706 __STRING_INLINE char * 707 __stpcpy_small (char *__dest, 708 __STRING2_COPY_ARR2 __src2, __STRING2_COPY_ARR3 __src3, 709 __STRING2_COPY_ARR4 __src4, __STRING2_COPY_ARR5 __src5, 710 __STRING2_COPY_ARR6 __src6, __STRING2_COPY_ARR7 __src7, 711 __STRING2_COPY_ARR8 __src8, size_t __srclen) 712 { 713 union { 714 char __c; 715 __STRING2_COPY_ARR2 __sca2; 716 __STRING2_COPY_ARR3 __sca3; 717 __STRING2_COPY_ARR4 __sca4; 718 __STRING2_COPY_ARR5 __sca5; 719 __STRING2_COPY_ARR6 __sca6; 720 __STRING2_COPY_ARR7 __sca7; 721 __STRING2_COPY_ARR8 __sca8; 722 } *__u = (void *) __dest; 723 switch ((unsigned int) __srclen) 724 { 725 case 1: 726 __u->__c = '\0'; 727 break; 728 case 2: 729 __extension__ __u->__sca2 = __src2; 730 break; 731 case 3: 732 __extension__ __u->__sca3 = __src3; 733 break; 734 case 4: 735 __extension__ __u->__sca4 = __src4; 736 break; 737 case 5: 738 __extension__ __u->__sca5 = __src5; 739 break; 740 case 6: 741 __extension__ __u->__sca6 = __src6; 742 break; 743 case 7: 744 __extension__ __u->__sca7 = __src7; 745 break; 746 case 8: 747 __extension__ __u->__sca8 = __src8; 748 break; 749 } 750 return __dest + __srclen - 1; 751 } 752 # endif 753 # endif 754 # endif 755 #endif 756 757 758 /* Copy no more than N characters of SRC to DEST. */ 759 #ifndef _HAVE_STRING_ARCH_strncpy 760 # if __GNUC_PREREQ (3, 2) 761 # define strncpy(dest, src, n) __builtin_strncpy (dest, src, n) 762 # else 763 # define strncpy(dest, src, n) \ 764 (__extension__ (__builtin_constant_p (src) && __builtin_constant_p (n) \ 765 ? (strlen (src) + 1 >= ((size_t) (n)) \ 766 ? (char *) memcpy (dest, src, n) \ 767 : strncpy (dest, src, n)) \ 768 : strncpy (dest, src, n))) 769 # endif 770 #endif 771 772 773 /* Append no more than N characters from SRC onto DEST. */ 774 #ifndef _HAVE_STRING_ARCH_strncat 775 # ifdef _USE_STRING_ARCH_strchr 776 # define strncat(dest, src, n) \ 777 (__extension__ ({ char *__dest = (dest); \ 778 __builtin_constant_p (src) && __builtin_constant_p (n) \ 779 ? (strlen (src) < ((size_t) (n)) \ 780 ? strcat (__dest, src) \ 781 : (*((char *) __mempcpy (strchr (__dest, '\0'), \ 782 src, n)) = '\0', __dest)) \ 783 : strncat (dest, src, n); })) 784 # elif __GNUC_PREREQ (3, 2) 785 # define strncat(dest, src, n) __builtin_strncat (dest, src, n) 786 # else 787 # define strncat(dest, src, n) \ 788 (__extension__ (__builtin_constant_p (src) && __builtin_constant_p (n) \ 789 ? (strlen (src) < ((size_t) (n)) \ 790 ? strcat (dest, src) \ 791 : strncat (dest, src, n)) \ 792 : strncat (dest, src, n))) 793 # endif 794 #endif 795 796 797 /* Compare characters of S1 and S2. */ 798 #ifndef _HAVE_STRING_ARCH_strcmp 799 # if __GNUC_PREREQ (3, 2) 800 # define strcmp(s1, s2) \ 801 __extension__ \ 802 ({ size_t __s1_len, __s2_len; \ 803 (__builtin_constant_p (s1) && __builtin_constant_p (s2) \ 804 && (__s1_len = strlen (s1), __s2_len = strlen (s2), \ 805 (!__string2_1bptr_p (s1) || __s1_len >= 4) \ 806 && (!__string2_1bptr_p (s2) || __s2_len >= 4)) \ 807 ? __builtin_strcmp (s1, s2) \ 808 : (__builtin_constant_p (s1) && __string2_1bptr_p (s1) \ 809 && (__s1_len = strlen (s1), __s1_len < 4) \ 810 ? (__builtin_constant_p (s2) && __string2_1bptr_p (s2) \ 811 ? __builtin_strcmp (s1, s2) \ 812 : __strcmp_cg (s1, s2, __s1_len)) \ 813 : (__builtin_constant_p (s2) && __string2_1bptr_p (s2) \ 814 && (__s2_len = strlen (s2), __s2_len < 4) \ 815 ? (__builtin_constant_p (s1) && __string2_1bptr_p (s1) \ 816 ? __builtin_strcmp (s1, s2) \ 817 : __strcmp_gc (s1, s2, __s2_len)) \ 818 : __builtin_strcmp (s1, s2)))); }) 819 # else 820 # define strcmp(s1, s2) \ 821 __extension__ \ 822 ({ size_t __s1_len, __s2_len; \ 823 (__builtin_constant_p (s1) && __builtin_constant_p (s2) \ 824 && (__s1_len = strlen (s1), __s2_len = strlen (s2), \ 825 (!__string2_1bptr_p (s1) || __s1_len >= 4) \ 826 && (!__string2_1bptr_p (s2) || __s2_len >= 4)) \ 827 ? memcmp ((__const char *) (s1), (__const char *) (s2), \ 828 (__s1_len < __s2_len ? __s1_len : __s2_len) + 1) \ 829 : (__builtin_constant_p (s1) && __string2_1bptr_p (s1) \ 830 && (__s1_len = strlen (s1), __s1_len < 4) \ 831 ? (__builtin_constant_p (s2) && __string2_1bptr_p (s2) \ 832 ? __strcmp_cc (s1, s2, __s1_len) \ 833 : __strcmp_cg (s1, s2, __s1_len)) \ 834 : (__builtin_constant_p (s2) && __string2_1bptr_p (s2) \ 835 && (__s2_len = strlen (s2), __s2_len < 4) \ 836 ? (__builtin_constant_p (s1) && __string2_1bptr_p (s1) \ 837 ? __strcmp_cc (s1, s2, __s2_len) \ 838 : __strcmp_gc (s1, s2, __s2_len)) \ 839 : strcmp (s1, s2)))); }) 840 # endif 841 842 # define __strcmp_cc(s1, s2, l) \ 843 (__extension__ ({ register int __result = \ 844 (((__const unsigned char *) (__const char *) (s1))[0] \ 845 - ((__const unsigned char *) (__const char *)(s2))[0]);\ 846 if (l > 0 && __result == 0) \ 847 { \ 848 __result = (((__const unsigned char *) \ 849 (__const char *) (s1))[1] \ 850 - ((__const unsigned char *) \ 851 (__const char *) (s2))[1]); \ 852 if (l > 1 && __result == 0) \ 853 { \ 854 __result = \ 855 (((__const unsigned char *) \ 856 (__const char *) (s1))[2] \ 857 - ((__const unsigned char *) \ 858 (__const char *) (s2))[2]); \ 859 if (l > 2 && __result == 0) \ 860 __result = \ 861 (((__const unsigned char *) \ 862 (__const char *) (s1))[3] \ 863 - ((__const unsigned char *) \ 864 (__const char *) (s2))[3]); \ 865 } \ 866 } \ 867 __result; })) 868 869 # define __strcmp_cg(s1, s2, l1) \ 870 (__extension__ ({ __const unsigned char *__s2 = \ 871 (__const unsigned char *) (__const char *) (s2); \ 872 register int __result = \ 873 (((__const unsigned char *) (__const char *) (s1))[0] \ 874 - __s2[0]); \ 875 if (l1 > 0 && __result == 0) \ 876 { \ 877 __result = (((__const unsigned char *) \ 878 (__const char *) (s1))[1] - __s2[1]); \ 879 if (l1 > 1 && __result == 0) \ 880 { \ 881 __result = (((__const unsigned char *) \ 882 (__const char *) (s1))[2] - __s2[2]);\ 883 if (l1 > 2 && __result == 0) \ 884 __result = (((__const unsigned char *) \ 885 (__const char *) (s1))[3] \ 886 - __s2[3]); \ 887 } \ 888 } \ 889 __result; })) 890 891 # define __strcmp_gc(s1, s2, l2) \ 892 (__extension__ ({ __const unsigned char *__s1 = \ 893 (__const unsigned char *) (__const char *) (s1); \ 894 register int __result = \ 895 __s1[0] - ((__const unsigned char *) \ 896 (__const char *) (s2))[0]; \ 897 if (l2 > 0 && __result == 0) \ 898 { \ 899 __result = (__s1[1] \ 900 - ((__const unsigned char *) \ 901 (__const char *) (s2))[1]); \ 902 if (l2 > 1 && __result == 0) \ 903 { \ 904 __result = \ 905 (__s1[2] - ((__const unsigned char *) \ 906 (__const char *) (s2))[2]); \ 907 if (l2 > 2 && __result == 0) \ 908 __result = \ 909 (__s1[3] \ 910 - ((__const unsigned char *) \ 911 (__const char *) (s2))[3]); \ 912 } \ 913 } \ 914 __result; })) 915 #endif 916 917 918 /* Compare N characters of S1 and S2. */ 919 #ifndef _HAVE_STRING_ARCH_strncmp 920 # define strncmp(s1, s2, n) \ 921 (__extension__ (__builtin_constant_p (n) \ 922 && ((__builtin_constant_p (s1) \ 923 && strlen (s1) < ((size_t) (n))) \ 924 || (__builtin_constant_p (s2) \ 925 && strlen (s2) < ((size_t) (n)))) \ 926 ? strcmp (s1, s2) : strncmp (s1, s2, n))) 927 #endif 928 929 930 /* Return the length of the initial segment of S which 931 consists entirely of characters not in REJECT. */ 932 #if !defined _HAVE_STRING_ARCH_strcspn || defined _FORCE_INLINES 933 # ifndef _HAVE_STRING_ARCH_strcspn 934 # if __GNUC_PREREQ (3, 2) 935 # define strcspn(s, reject) \ 936 __extension__ \ 937 ({ char __r0, __r1, __r2; \ 938 (__builtin_constant_p (reject) && __string2_1bptr_p (reject) \ 939 ? ((__builtin_constant_p (s) && __string2_1bptr_p (s)) \ 940 ? __builtin_strcspn (s, reject) \ 941 : ((__r0 = ((__const char *) (reject))[0], __r0 == '\0') \ 942 ? strlen (s) \ 943 : ((__r1 = ((__const char *) (reject))[1], __r1 == '\0') \ 944 ? __strcspn_c1 (s, __r0) \ 945 : ((__r2 = ((__const char *) (reject))[2], __r2 == '\0') \ 946 ? __strcspn_c2 (s, __r0, __r1) \ 947 : (((__const char *) (reject))[3] == '\0' \ 948 ? __strcspn_c3 (s, __r0, __r1, __r2) \ 949 : __builtin_strcspn (s, reject)))))) \ 950 : __builtin_strcspn (s, reject)); }) 951 # else 952 # define strcspn(s, reject) \ 953 __extension__ \ 954 ({ char __r0, __r1, __r2; \ 955 (__builtin_constant_p (reject) && __string2_1bptr_p (reject) \ 956 ? ((__r0 = ((__const char *) (reject))[0], __r0 == '\0') \ 957 ? strlen (s) \ 958 : ((__r1 = ((__const char *) (reject))[1], __r1 == '\0') \ 959 ? __strcspn_c1 (s, __r0) \ 960 : ((__r2 = ((__const char *) (reject))[2], __r2 == '\0') \ 961 ? __strcspn_c2 (s, __r0, __r1) \ 962 : (((__const char *) (reject))[3] == '\0' \ 963 ? __strcspn_c3 (s, __r0, __r1, __r2) \ 964 : strcspn (s, reject))))) \ 965 : strcspn (s, reject)); }) 966 # endif 967 # endif 968 969 __STRING_INLINE size_t __strcspn_c1 (__const char *__s, int __reject); 970 __STRING_INLINE size_t 971 __strcspn_c1 (__const char *__s, int __reject) 972 { 973 register size_t __result = 0; 974 while (__s[__result] != '\0' && __s[__result] != __reject) 975 ++__result; 976 return __result; 977 } 978 979 __STRING_INLINE size_t __strcspn_c2 (__const char *__s, int __reject1, 980 int __reject2); 981 __STRING_INLINE size_t 982 __strcspn_c2 (__const char *__s, int __reject1, int __reject2) 983 { 984 register size_t __result = 0; 985 while (__s[__result] != '\0' && __s[__result] != __reject1 986 && __s[__result] != __reject2) 987 ++__result; 988 return __result; 989 } 990 991 __STRING_INLINE size_t __strcspn_c3 (__const char *__s, int __reject1, 992 int __reject2, int __reject3); 993 __STRING_INLINE size_t 994 __strcspn_c3 (__const char *__s, int __reject1, int __reject2, 995 int __reject3) 996 { 997 register size_t __result = 0; 998 while (__s[__result] != '\0' && __s[__result] != __reject1 999 && __s[__result] != __reject2 && __s[__result] != __reject3) 1000 ++__result; 1001 return __result; 1002 } 1003 #endif 1004 1005 1006 /* Return the length of the initial segment of S which 1007 consists entirely of characters in ACCEPT. */ 1008 #if !defined _HAVE_STRING_ARCH_strspn || defined _FORCE_INLINES 1009 # ifndef _HAVE_STRING_ARCH_strspn 1010 # if __GNUC_PREREQ (3, 2) 1011 # define strspn(s, accept) \ 1012 __extension__ \ 1013 ({ char __a0, __a1, __a2; \ 1014 (__builtin_constant_p (accept) && __string2_1bptr_p (accept) \ 1015 ? ((__builtin_constant_p (s) && __string2_1bptr_p (s)) \ 1016 ? __builtin_strspn (s, accept) \ 1017 : ((__a0 = ((__const char *) (accept))[0], __a0 == '\0') \ 1018 ? ((void) (s), 0) \ 1019 : ((__a1 = ((__const char *) (accept))[1], __a1 == '\0') \ 1020 ? __strspn_c1 (s, __a0) \ 1021 : ((__a2 = ((__const char *) (accept))[2], __a2 == '\0') \ 1022 ? __strspn_c2 (s, __a0, __a1) \ 1023 : (((__const char *) (accept))[3] == '\0' \ 1024 ? __strspn_c3 (s, __a0, __a1, __a2) \ 1025 : __builtin_strspn (s, accept)))))) \ 1026 : __builtin_strspn (s, accept)); }) 1027 # else 1028 # define strspn(s, accept) \ 1029 __extension__ \ 1030 ({ char __a0, __a1, __a2; \ 1031 (__builtin_constant_p (accept) && __string2_1bptr_p (accept) \ 1032 ? ((__a0 = ((__const char *) (accept))[0], __a0 == '\0') \ 1033 ? ((void) (s), 0) \ 1034 : ((__a1 = ((__const char *) (accept))[1], __a1 == '\0') \ 1035 ? __strspn_c1 (s, __a0) \ 1036 : ((__a2 = ((__const char *) (accept))[2], __a2 == '\0') \ 1037 ? __strspn_c2 (s, __a0, __a1) \ 1038 : (((__const char *) (accept))[3] == '\0' \ 1039 ? __strspn_c3 (s, __a0, __a1, __a2) \ 1040 : strspn (s, accept))))) \ 1041 : strspn (s, accept)); }) 1042 # endif 1043 # endif 1044 1045 __STRING_INLINE size_t __strspn_c1 (__const char *__s, int __accept); 1046 __STRING_INLINE size_t 1047 __strspn_c1 (__const char *__s, int __accept) 1048 { 1049 register size_t __result = 0; 1050 /* Please note that __accept never can be '\0'. */ 1051 while (__s[__result] == __accept) 1052 ++__result; 1053 return __result; 1054 } 1055 1056 __STRING_INLINE size_t __strspn_c2 (__const char *__s, int __accept1, 1057 int __accept2); 1058 __STRING_INLINE size_t 1059 __strspn_c2 (__const char *__s, int __accept1, int __accept2) 1060 { 1061 register size_t __result = 0; 1062 /* Please note that __accept1 and __accept2 never can be '\0'. */ 1063 while (__s[__result] == __accept1 || __s[__result] == __accept2) 1064 ++__result; 1065 return __result; 1066 } 1067 1068 __STRING_INLINE size_t __strspn_c3 (__const char *__s, int __accept1, 1069 int __accept2, int __accept3); 1070 __STRING_INLINE size_t 1071 __strspn_c3 (__const char *__s, int __accept1, int __accept2, int __accept3) 1072 { 1073 register size_t __result = 0; 1074 /* Please note that __accept1 to __accept3 never can be '\0'. */ 1075 while (__s[__result] == __accept1 || __s[__result] == __accept2 1076 || __s[__result] == __accept3) 1077 ++__result; 1078 return __result; 1079 } 1080 #endif 1081 1082 1083 /* Find the first occurrence in S of any character in ACCEPT. */ 1084 #if !defined _HAVE_STRING_ARCH_strpbrk || defined _FORCE_INLINES 1085 # ifndef _HAVE_STRING_ARCH_strpbrk 1086 # if __GNUC_PREREQ (3, 2) 1087 # define strpbrk(s, accept) \ 1088 __extension__ \ 1089 ({ char __a0, __a1, __a2; \ 1090 (__builtin_constant_p (accept) && __string2_1bptr_p (accept) \ 1091 ? ((__builtin_constant_p (s) && __string2_1bptr_p (s)) \ 1092 ? __builtin_strpbrk (s, accept) \ 1093 : ((__a0 = ((__const char *) (accept))[0], __a0 == '\0') \ 1094 ? ((void) (s), (char *) NULL) \ 1095 : ((__a1 = ((__const char *) (accept))[1], __a1 == '\0') \ 1096 ? __builtin_strchr (s, __a0) \ 1097 : ((__a2 = ((__const char *) (accept))[2], __a2 == '\0') \ 1098 ? __strpbrk_c2 (s, __a0, __a1) \ 1099 : (((__const char *) (accept))[3] == '\0' \ 1100 ? __strpbrk_c3 (s, __a0, __a1, __a2) \ 1101 : __builtin_strpbrk (s, accept)))))) \ 1102 : __builtin_strpbrk (s, accept)); }) 1103 # else 1104 # define strpbrk(s, accept) \ 1105 __extension__ \ 1106 ({ char __a0, __a1, __a2; \ 1107 (__builtin_constant_p (accept) && __string2_1bptr_p (accept) \ 1108 ? ((__a0 = ((__const char *) (accept))[0], __a0 == '\0') \ 1109 ? ((void) (s), (char *) NULL) \ 1110 : ((__a1 = ((__const char *) (accept))[1], __a1 == '\0') \ 1111 ? strchr (s, __a0) \ 1112 : ((__a2 = ((__const char *) (accept))[2], __a2 == '\0') \ 1113 ? __strpbrk_c2 (s, __a0, __a1) \ 1114 : (((__const char *) (accept))[3] == '\0' \ 1115 ? __strpbrk_c3 (s, __a0, __a1, __a2) \ 1116 : strpbrk (s, accept))))) \ 1117 : strpbrk (s, accept)); }) 1118 # endif 1119 # endif 1120 1121 __STRING_INLINE char *__strpbrk_c2 (__const char *__s, int __accept1, 1122 int __accept2); 1123 __STRING_INLINE char * 1124 __strpbrk_c2 (__const char *__s, int __accept1, int __accept2) 1125 { 1126 /* Please note that __accept1 and __accept2 never can be '\0'. */ 1127 while (*__s != '\0' && *__s != __accept1 && *__s != __accept2) 1128 ++__s; 1129 return *__s == '\0' ? NULL : (char *) (size_t) __s; 1130 } 1131 1132 __STRING_INLINE char *__strpbrk_c3 (__const char *__s, int __accept1, 1133 int __accept2, int __accept3); 1134 __STRING_INLINE char * 1135 __strpbrk_c3 (__const char *__s, int __accept1, int __accept2, 1136 int __accept3) 1137 { 1138 /* Please note that __accept1 to __accept3 never can be '\0'. */ 1139 while (*__s != '\0' && *__s != __accept1 && *__s != __accept2 1140 && *__s != __accept3) 1141 ++__s; 1142 return *__s == '\0' ? NULL : (char *) (size_t) __s; 1143 } 1144 #endif 1145 1146 1147 /* Find the first occurrence of NEEDLE in HAYSTACK. Newer gcc versions 1148 do this itself. */ 1149 #if !defined _HAVE_STRING_ARCH_strstr && !__GNUC_PREREQ (2, 97) 1150 # define strstr(haystack, needle) \ 1151 (__extension__ (__builtin_constant_p (needle) && __string2_1bptr_p (needle) \ 1152 ? (((__const char *) (needle))[0] == '\0' \ 1153 ? (char *) (size_t) (haystack) \ 1154 : (((__const char *) (needle))[1] == '\0' \ 1155 ? strchr (haystack, \ 1156 ((__const char *) (needle))[0]) \ 1157 : strstr (haystack, needle))) \ 1158 : strstr (haystack, needle))) 1159 #endif 1160 1161 1162 #if !defined _HAVE_STRING_ARCH_strtok_r || defined _FORCE_INLINES 1163 # ifndef _HAVE_STRING_ARCH_strtok_r 1164 # define __strtok_r(s, sep, nextp) \ 1165 (__extension__ (__builtin_constant_p (sep) && __string2_1bptr_p (sep) \ 1166 ? (((__const char *) (sep))[0] != '\0' \ 1167 && ((__const char *) (sep))[1] == '\0' \ 1168 ? __strtok_r_1c (s, ((__const char *) (sep))[0], nextp) \ 1169 : __strtok_r (s, sep, nextp)) \ 1170 : __strtok_r (s, sep, nextp))) 1171 # endif 1172 1173 __STRING_INLINE char *__strtok_r_1c (char *__s, char __sep, char **__nextp); 1174 __STRING_INLINE char * 1175 __strtok_r_1c (char *__s, char __sep, char **__nextp) 1176 { 1177 char *__result; 1178 if (__s == NULL) 1179 __s = *__nextp; 1180 while (*__s == __sep) 1181 ++__s; 1182 __result = NULL; 1183 if (*__s != '\0') 1184 { 1185 __result = __s++; 1186 while (*__s != '\0') 1187 if (*__s++ == __sep) 1188 { 1189 __s[-1] = '\0'; 1190 break; 1191 } 1192 *__nextp = __s; 1193 } 1194 return __result; 1195 } 1196 # if defined __USE_POSIX || defined __USE_MISC 1197 # define strtok_r(s, sep, nextp) __strtok_r (s, sep, nextp) 1198 # endif 1199 #endif 1200 1201 1202 #if !defined _HAVE_STRING_ARCH_strsep || defined _FORCE_INLINES 1203 # ifndef _HAVE_STRING_ARCH_strsep 1204 1205 extern char *__strsep_g (char **__stringp, __const char *__delim); 1206 # define __strsep(s, reject) \ 1207 __extension__ \ 1208 ({ char __r0, __r1, __r2; \ 1209 (__builtin_constant_p (reject) && __string2_1bptr_p (reject) \ 1210 && (__r0 = ((__const char *) (reject))[0], \ 1211 ((__const char *) (reject))[0] != '\0') \ 1212 ? ((__r1 = ((__const char *) (reject))[1], \ 1213 ((__const char *) (reject))[1] == '\0') \ 1214 ? __strsep_1c (s, __r0) \ 1215 : ((__r2 = ((__const char *) (reject))[2], __r2 == '\0') \ 1216 ? __strsep_2c (s, __r0, __r1) \ 1217 : (((__const char *) (reject))[3] == '\0' \ 1218 ? __strsep_3c (s, __r0, __r1, __r2) \ 1219 : __strsep_g (s, reject)))) \ 1220 : __strsep_g (s, reject)); }) 1221 # endif 1222 1223 __STRING_INLINE char *__strsep_1c (char **__s, char __reject); 1224 __STRING_INLINE char * 1225 __strsep_1c (char **__s, char __reject) 1226 { 1227 register char *__retval = *__s; 1228 if (__retval != NULL && (*__s = strchr (__retval, __reject)) != NULL) 1229 *(*__s)++ = '\0'; 1230 return __retval; 1231 } 1232 1233 __STRING_INLINE char *__strsep_2c (char **__s, char __reject1, char __reject2); 1234 __STRING_INLINE char * 1235 __strsep_2c (char **__s, char __reject1, char __reject2) 1236 { 1237 register char *__retval = *__s; 1238 if (__retval != NULL) 1239 { 1240 register char *__cp = __retval; 1241 while (1) 1242 { 1243 if (*__cp == '\0') 1244 { 1245 __cp = NULL; 1246 break; 1247 } 1248 if (*__cp == __reject1 || *__cp == __reject2) 1249 { 1250 *__cp++ = '\0'; 1251 break; 1252 } 1253 ++__cp; 1254 } 1255 *__s = __cp; 1256 } 1257 return __retval; 1258 } 1259 1260 __STRING_INLINE char *__strsep_3c (char **__s, char __reject1, char __reject2, 1261 char __reject3); 1262 __STRING_INLINE char * 1263 __strsep_3c (char **__s, char __reject1, char __reject2, char __reject3) 1264 { 1265 register char *__retval = *__s; 1266 if (__retval != NULL) 1267 { 1268 register char *__cp = __retval; 1269 while (1) 1270 { 1271 if (*__cp == '\0') 1272 { 1273 __cp = NULL; 1274 break; 1275 } 1276 if (*__cp == __reject1 || *__cp == __reject2 || *__cp == __reject3) 1277 { 1278 *__cp++ = '\0'; 1279 break; 1280 } 1281 ++__cp; 1282 } 1283 *__s = __cp; 1284 } 1285 return __retval; 1286 } 1287 # ifdef __USE_BSD 1288 # define strsep(s, reject) __strsep (s, reject) 1289 # endif 1290 #endif 1291 1292 /* We need the memory allocation functions for inline strdup(). 1293 Referring to stdlib.h (even minimally) is not allowed 1294 in any of the tight standards compliant modes. */ 1295 #ifdef __USE_MISC 1296 1297 # if !defined _HAVE_STRING_ARCH_strdup || !defined _HAVE_STRING_ARCH_strndup 1298 # define __need_malloc_and_calloc 1299 # include <stdlib.h> 1300 # endif 1301 1302 # ifndef _HAVE_STRING_ARCH_strdup 1303 1304 extern char *__strdup (__const char *__string) __THROW __attribute_malloc__; 1305 # define __strdup(s) \ 1306 (__extension__ (__builtin_constant_p (s) && __string2_1bptr_p (s) \ 1307 ? (((__const char *) (s))[0] == '\0' \ 1308 ? (char *) calloc ((size_t) 1, (size_t) 1) \ 1309 : ({ size_t __len = strlen (s) + 1; \ 1310 char *__retval = (char *) malloc (__len); \ 1311 if (__retval != NULL) \ 1312 __retval = (char *) memcpy (__retval, s, __len); \ 1313 __retval; })) \ 1314 : __strdup (s))) 1315 1316 # if defined __USE_SVID || defined __USE_BSD || defined __USE_XOPEN_EXTENDED 1317 # define strdup(s) __strdup (s) 1318 # endif 1319 # endif 1320 1321 # ifndef _HAVE_STRING_ARCH_strndup 1322 1323 extern char *__strndup (__const char *__string, size_t __n) 1324 __THROW __attribute_malloc__; 1325 # define __strndup(s, n) \ 1326 (__extension__ (__builtin_constant_p (s) && __string2_1bptr_p (s) \ 1327 ? (((__const char *) (s))[0] == '\0' \ 1328 ? (char *) calloc ((size_t) 1, (size_t) 1) \ 1329 : ({ size_t __len = strlen (s) + 1; \ 1330 size_t __n = (n); \ 1331 char *__retval; \ 1332 if (__n < __len) \ 1333 __len = __n + 1; \ 1334 __retval = (char *) malloc (__len); \ 1335 if (__retval != NULL) \ 1336 { \ 1337 __retval[__len - 1] = '\0'; \ 1338 __retval = (char *) memcpy (__retval, s, \ 1339 __len - 1); \ 1340 } \ 1341 __retval; })) \ 1342 : __strndup (s, n))) 1343 1344 # ifdef __USE_GNU 1345 # define strndup(s, n) __strndup (s, n) 1346 # endif 1347 # endif 1348 1349 #endif /* Use misc. or use GNU. */ 1350 1351 #ifndef _FORCE_INLINES 1352 # undef __STRING_INLINE 1353 #endif 1354 1355 #endif /* No string inlines. */ 1356
