string/bits/string2.h

   1 /* Machine-independant string function optimizations.
   2    Copyright (C) 1997-2004, 2007, 2008, 2012 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@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, int __accept3)
1136 {
1137   /* Please note that __accept1 to __accept3 never can be '\0'.  */
1138   while (*__s != '\0' && *__s != __accept1 && *__s != __accept2
1139          && *__s != __accept3)
1140     ++__s;
1141   return *__s == '\0' ? NULL : (char *) (size_t) __s;
1142 }
1143 #endif
1144
1145
1146 /* Find the first occurrence of NEEDLE in HAYSTACK.  Newer gcc versions
1147    do this itself.  */
1148 #if !defined _HAVE_STRING_ARCH_strstr && !__GNUC_PREREQ (2, 97)
1149 # define strstr(haystack, needle) \
1150   (__extension__ (__builtin_constant_p (needle) && __string2_1bptr_p (needle) \
1151                   ? (((const char *) (needle))[0] == '\0'                     \
1152                      ? (char *) (size_t) (haystack)                           \
1153                      : (((const char *) (needle))[1] == '\0'                  \
1154                         ? strchr (haystack,                                   \
1155                                   ((const char *) (needle))[0])               \
1156                         : strstr (haystack, needle)))                         \
1157                   : strstr (haystack, needle)))
1158 #endif
1159
1160
1161 #if !defined _HAVE_STRING_ARCH_strtok_r || defined _FORCE_INLINES
1162 # ifndef _HAVE_STRING_ARCH_strtok_r
1163 #  define __strtok_r(s, sep, nextp) \
1164   (__extension__ (__builtin_constant_p (sep) && __string2_1bptr_p (sep)       \
1165                   && ((const char *) (sep))[0] != '\0'                        \
1166                   && ((const char *) (sep))[1] == '\0'                        \
1167                   ? __strtok_r_1c (s, ((const char *) (sep))[0], nextp)       \
1168                   : __strtok_r (s, sep, nextp)))
1169 # endif
1170
1171 __STRING_INLINE char *__strtok_r_1c (char *__s, char __sep, char **__nextp);
1172 __STRING_INLINE char *
1173 __strtok_r_1c (char *__s, char __sep, char **__nextp)
1174 {
1175   char *__result;
1176   if (__s == NULL)
1177     __s = *__nextp;
1178   while (*__s == __sep)
1179     ++__s;
1180   __result = NULL;
1181   if (*__s != '\0')
1182     {
1183       __result = __s++;
1184       while (*__s != '\0')
1185         if (*__s++ == __sep)
1186           {
1187             __s[-1] = '\0';
1188             break;
1189           }
1190     }
1191   *__nextp = __s;
1192   return __result;
1193 }
1194 # if defined __USE_POSIX || defined __USE_MISC
1195 #  define strtok_r(s, sep, nextp) __strtok_r (s, sep, nextp)
1196 # endif
1197 #endif
1198
1199
1200 #if !defined _HAVE_STRING_ARCH_strsep || defined _FORCE_INLINES
1201 # ifndef _HAVE_STRING_ARCH_strsep
1202
1203 extern char *__strsep_g (char **__stringp, const char *__delim);
1204 #  define __strsep(s, reject) \
1205   __extension__                                                               \
1206   ({ char __r0, __r1, __r2;                                                   \
1207      (__builtin_constant_p (reject) && __string2_1bptr_p (reject)             \
1208       && (__r0 = ((const char *) (reject))[0],                                \
1209           ((const char *) (reject))[0] != '\0')                               \
1210       ? ((__r1 = ((const char *) (reject))[1],                                \
1211          ((const char *) (reject))[1] == '\0')                                \
1212          ? __strsep_1c (s, __r0)                                              \
1213          : ((__r2 = ((const char *) (reject))[2], __r2 == '\0')               \
1214             ? __strsep_2c (s, __r0, __r1)                                     \
1215             : (((const char *) (reject))[3] == '\0'                           \
1216                ? __strsep_3c (s, __r0, __r1, __r2)                            \
1217                : __strsep_g (s, reject))))                                    \
1218       : __strsep_g (s, reject)); })
1219 # endif
1220
1221 __STRING_INLINE char *__strsep_1c (char **__s, char __reject);
1222 __STRING_INLINE char *
1223 __strsep_1c (char **__s, char __reject)
1224 {
1225   register char *__retval = *__s;
1226   if (__retval != NULL && (*__s = strchr (__retval, __reject)) != NULL)
1227     *(*__s)++ = '\0';
1228   return __retval;
1229 }
1230
1231 __STRING_INLINE char *__strsep_2c (char **__s, char __reject1, char __reject2);
1232 __STRING_INLINE char *
1233 __strsep_2c (char **__s, char __reject1, char __reject2)
1234 {
1235   register char *__retval = *__s;
1236   if (__retval != NULL)
1237     {
1238       register char *__cp = __retval;
1239       while (1)
1240         {
1241           if (*__cp == '\0')
1242             {
1243               __cp = NULL;
1244           break;
1245             }
1246           if (*__cp == __reject1 || *__cp == __reject2)
1247             {
1248               *__cp++ = '\0';
1249               break;
1250             }
1251           ++__cp;
1252         }
1253       *__s = __cp;
1254     }
1255   return __retval;
1256 }
1257
1258 __STRING_INLINE char *__strsep_3c (char **__s, char __reject1, char __reject2,
1259                                    char __reject3);
1260 __STRING_INLINE char *
1261 __strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
1262 {
1263   register char *__retval = *__s;
1264   if (__retval != NULL)
1265     {
1266       register char *__cp = __retval;
1267       while (1)
1268         {
1269           if (*__cp == '\0')
1270             {
1271               __cp = NULL;
1272           break;
1273             }
1274           if (*__cp == __reject1 || *__cp == __reject2 || *__cp == __reject3)
1275             {
1276               *__cp++ = '\0';
1277               break;
1278             }
1279           ++__cp;
1280         }
1281       *__s = __cp;
1282     }
1283   return __retval;
1284 }
1285 # ifdef __USE_BSD
1286 #  define strsep(s, reject) __strsep (s, reject)
1287 # endif
1288 #endif
1289
1290 /* We need the memory allocation functions for inline strdup().
1291    Referring to stdlib.h (even minimally) is not allowed
1292    in any of the tight standards compliant modes.  */
1293 #ifdef __USE_MISC
1294
1295 # if !defined _HAVE_STRING_ARCH_strdup || !defined _HAVE_STRING_ARCH_strndup
1296 #  define __need_malloc_and_calloc
1297 #  include <stdlib.h>
1298 # endif
1299
1300 # ifndef _HAVE_STRING_ARCH_strdup
1301
1302 extern char *__strdup (const char *__string) __THROW __attribute_malloc__;
1303 #  define __strdup(s) \
1304   (__extension__ (__builtin_constant_p (s) && __string2_1bptr_p (s)           \
1305                   ? (((const char *) (s))[0] == '\0'                          \
1306                      ? (char *) calloc ((size_t) 1, (size_t) 1)               \
1307                      : ({ size_t __len = strlen (s) + 1;                      \
1308                           char *__retval = (char *) malloc (__len);           \
1309                           if (__retval != NULL)                               \
1310                             __retval = (char *) memcpy (__retval, s, __len);  \
1311                           __retval; }))                                       \
1312                   : __strdup (s)))
1313
1314 #  if defined __USE_SVID || defined __USE_BSD || defined __USE_XOPEN_EXTENDED
1315 #   define strdup(s) __strdup (s)
1316 #  endif
1317 # endif
1318
1319 # ifndef _HAVE_STRING_ARCH_strndup
1320
1321 extern char *__strndup (const char *__string, size_t __n)
1322      __THROW __attribute_malloc__;
1323 #  define __strndup(s, n) \
1324   (__extension__ (__builtin_constant_p (s) && __string2_1bptr_p (s)           \
1325                   ? (((const char *) (s))[0] == '\0'                          \
1326                      ? (char *) calloc ((size_t) 1, (size_t) 1)               \
1327                      : ({ size_t __len = strlen (s) + 1;                      \
1328                           size_t __n = (n);                                   \
1329                           char *__retval;                                     \
1330                           if (__n < __len)                                    \
1331                             __len = __n + 1;                                  \
1332                           __retval = (char *) malloc (__len);                 \
1333                           if (__retval != NULL)                               \
1334                             {                                                 \
1335                               __retval[__len - 1] = '\0';                     \
1336                               __retval = (char *) memcpy (__retval, s,        \
1337                                                           __len - 1);         \
1338                             }                                                 \
1339                           __retval; }))                                       \
1340                   : __strndup (s, n)))
1341
1342 #  ifdef __USE_GNU
1343 #   define strndup(s, n) __strndup (s, n)
1344 #  endif
1345 # endif
1346
1347 #endif /* Use misc. or use GNU.  */
1348
1349 #ifndef _FORCE_INLINES
1350 # undef __STRING_INLINE
1351 #endif
1352
1353 #endif /* No string inlines.  */