LCOV - code coverage report
Current view: top level - usr/include/bits - string2.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 3 3 100.0 %
Date: 2012-11-29 Functions: 0 0 -
Branches: 4 8 50.0 %

           Branch data     Line data    Source code
       1                 :            : /* Machine-independant string function optimizations.
       2                 :            :    Copyright (C) 1997-2003, 2004, 2007, 2008 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                 :          5 :   register size_t __result = 0;
     974 [ +  + ][ +  + ]:         85 :   while (__s[__result] != '\0' && __s[__result] != __reject)
         [ #  # ][ #  # ]
     975                 :         80 :     ++__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                 :            : # endif
    1171                 :            : 
    1172                 :            : __STRING_INLINE char *__strtok_r_1c (char *__s, char __sep, char **__nextp);
    1173                 :            : __STRING_INLINE char *
    1174                 :            : __strtok_r_1c (char *__s, char __sep, char **__nextp)
    1175                 :            : {
    1176                 :            :   char *__result;
    1177                 :            :   if (__s == NULL)
    1178                 :            :     __s = *__nextp;
    1179                 :            :   while (*__s == __sep)
    1180                 :            :     ++__s;
    1181                 :            :   __result = NULL;
    1182                 :            :   if (*__s != '\0')
    1183                 :            :     {
    1184                 :            :       __result = __s++;
    1185                 :            :       while (*__s != '\0')
    1186                 :            :         if (*__s++ == __sep)
    1187                 :            :           {
    1188                 :            :             __s[-1] = '\0';
    1189                 :            :             break;
    1190                 :            :           }
    1191                 :            :     }
    1192                 :            :   *__nextp = __s;
    1193                 :            :   return __result;
    1194                 :            : }
    1195                 :            : # if defined __USE_POSIX || defined __USE_MISC
    1196                 :            : #  define strtok_r(s, sep, nextp) __strtok_r (s, sep, nextp)
    1197                 :            : # endif
    1198                 :            : #endif
    1199                 :            : 
    1200                 :            : 
    1201                 :            : #if !defined _HAVE_STRING_ARCH_strsep || defined _FORCE_INLINES
    1202                 :            : # ifndef _HAVE_STRING_ARCH_strsep
    1203                 :            : 
    1204                 :            : extern char *__strsep_g (char **__stringp, __const char *__delim);
    1205                 :            : #  define __strsep(s, reject) \
    1206                 :            :   __extension__                                                               \
    1207                 :            :   ({ char __r0, __r1, __r2;                                                   \
    1208                 :            :      (__builtin_constant_p (reject) && __string2_1bptr_p (reject)             \
    1209                 :            :       && (__r0 = ((__const char *) (reject))[0],                              \
    1210                 :            :           ((__const char *) (reject))[0] != '\0')                             \
    1211                 :            :       ? ((__r1 = ((__const char *) (reject))[1],                              \
    1212                 :            :          ((__const char *) (reject))[1] == '\0')                              \
    1213                 :            :          ? __strsep_1c (s, __r0)                                              \
    1214                 :            :          : ((__r2 = ((__const char *) (reject))[2], __r2 == '\0')             \
    1215                 :            :             ? __strsep_2c (s, __r0, __r1)                                     \
    1216                 :            :             : (((__const char *) (reject))[3] == '\0'                         \
    1217                 :            :                ? __strsep_3c (s, __r0, __r1, __r2)                            \
    1218                 :            :                : __strsep_g (s, reject))))                                    \
    1219                 :            :       : __strsep_g (s, reject)); })
    1220                 :            : # endif
    1221                 :            : 
    1222                 :            : __STRING_INLINE char *__strsep_1c (char **__s, char __reject);
    1223                 :            : __STRING_INLINE char *
    1224                 :            : __strsep_1c (char **__s, char __reject)
    1225                 :            : {
    1226                 :            :   register char *__retval = *__s;
    1227                 :            :   if (__retval != NULL && (*__s = strchr (__retval, __reject)) != NULL)
    1228                 :            :     *(*__s)++ = '\0';
    1229                 :            :   return __retval;
    1230                 :            : }
    1231                 :            : 
    1232                 :            : __STRING_INLINE char *__strsep_2c (char **__s, char __reject1, char __reject2);
    1233                 :            : __STRING_INLINE char *
    1234                 :            : __strsep_2c (char **__s, char __reject1, char __reject2)
    1235                 :            : {
    1236                 :            :   register char *__retval = *__s;
    1237                 :            :   if (__retval != NULL)
    1238                 :            :     {
    1239                 :            :       register char *__cp = __retval;
    1240                 :            :       while (1)
    1241                 :            :         {
    1242                 :            :           if (*__cp == '\0')
    1243                 :            :             {
    1244                 :            :               __cp = NULL;
    1245                 :            :           break;
    1246                 :            :             }
    1247                 :            :           if (*__cp == __reject1 || *__cp == __reject2)
    1248                 :            :             {
    1249                 :            :               *__cp++ = '\0';
    1250                 :            :               break;
    1251                 :            :             }
    1252                 :            :           ++__cp;
    1253                 :            :         }
    1254                 :            :       *__s = __cp;
    1255                 :            :     }
    1256                 :            :   return __retval;
    1257                 :            : }
    1258                 :            : 
    1259                 :            : __STRING_INLINE char *__strsep_3c (char **__s, char __reject1, char __reject2,
    1260                 :            :                                    char __reject3);
    1261                 :            : __STRING_INLINE char *
    1262                 :            : __strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
    1263                 :            : {
    1264                 :            :   register char *__retval = *__s;
    1265                 :            :   if (__retval != NULL)
    1266                 :            :     {
    1267                 :            :       register char *__cp = __retval;
    1268                 :            :       while (1)
    1269                 :            :         {
    1270                 :            :           if (*__cp == '\0')
    1271                 :            :             {
    1272                 :            :               __cp = NULL;
    1273                 :            :           break;
    1274                 :            :             }
    1275                 :            :           if (*__cp == __reject1 || *__cp == __reject2 || *__cp == __reject3)
    1276                 :            :             {
    1277                 :            :               *__cp++ = '\0';
    1278                 :            :               break;
    1279                 :            :             }
    1280                 :            :           ++__cp;
    1281                 :            :         }
    1282                 :            :       *__s = __cp;
    1283                 :            :     }
    1284                 :            :   return __retval;
    1285                 :            : }
    1286                 :            : # ifdef __USE_BSD
    1287                 :            : #  define strsep(s, reject) __strsep (s, reject)
    1288                 :            : # endif
    1289                 :            : #endif
    1290                 :            : 
    1291                 :            : /* We need the memory allocation functions for inline strdup().
    1292                 :            :    Referring to stdlib.h (even minimally) is not allowed
    1293                 :            :    in any of the tight standards compliant modes.  */
    1294                 :            : #ifdef __USE_MISC
    1295                 :            : 
    1296                 :            : # if !defined _HAVE_STRING_ARCH_strdup || !defined _HAVE_STRING_ARCH_strndup
    1297                 :            : #  define __need_malloc_and_calloc
    1298                 :            : #  include <stdlib.h>
    1299                 :            : # endif
    1300                 :            : 
    1301                 :            : # ifndef _HAVE_STRING_ARCH_strdup
    1302                 :            : 
    1303                 :            : extern char *__strdup (__const char *__string) __THROW __attribute_malloc__;
    1304                 :            : #  define __strdup(s) \
    1305                 :            :   (__extension__ (__builtin_constant_p (s) && __string2_1bptr_p (s)           \
    1306                 :            :                   ? (((__const char *) (s))[0] == '\0'                        \
    1307                 :            :                      ? (char *) calloc ((size_t) 1, (size_t) 1)               \
    1308                 :            :                      : ({ size_t __len = strlen (s) + 1;                      \
    1309                 :            :                           char *__retval = (char *) malloc (__len);           \
    1310                 :            :                           if (__retval != NULL)                               \
    1311                 :            :                             __retval = (char *) memcpy (__retval, s, __len);  \
    1312                 :            :                           __retval; }))                                       \
    1313                 :            :                   : __strdup (s)))
    1314                 :            : 
    1315                 :            : #  if defined __USE_SVID || defined __USE_BSD || defined __USE_XOPEN_EXTENDED
    1316                 :            : #   define strdup(s) __strdup (s)
    1317                 :            : #  endif
    1318                 :            : # endif
    1319                 :            : 
    1320                 :            : # ifndef _HAVE_STRING_ARCH_strndup
    1321                 :            : 
    1322                 :            : extern char *__strndup (__const char *__string, size_t __n)
    1323                 :            :      __THROW __attribute_malloc__;
    1324                 :            : #  define __strndup(s, n) \
    1325                 :            :   (__extension__ (__builtin_constant_p (s) && __string2_1bptr_p (s)           \
    1326                 :            :                   ? (((__const char *) (s))[0] == '\0'                        \
    1327                 :            :                      ? (char *) calloc ((size_t) 1, (size_t) 1)               \
    1328                 :            :                      : ({ size_t __len = strlen (s) + 1;                      \
    1329                 :            :                           size_t __n = (n);                                   \
    1330                 :            :                           char *__retval;                                     \
    1331                 :            :                           if (__n < __len)                                 \
    1332                 :            :                             __len = __n + 1;                                  \
    1333                 :            :                           __retval = (char *) malloc (__len);                 \
    1334                 :            :                           if (__retval != NULL)                               \
    1335                 :            :                             {                                                 \
    1336                 :            :                               __retval[__len - 1] = '\0';                     \
    1337                 :            :                               __retval = (char *) memcpy (__retval, s,        \
    1338                 :            :                                                           __len - 1);         \
    1339                 :            :                             }                                                 \
    1340                 :            :                           __retval; }))                                       \
    1341                 :            :                   : __strndup (s, n)))
    1342                 :            : 
    1343                 :            : #  ifdef __USE_GNU
    1344                 :            : #   define strndup(s, n) __strndup (s, n)
    1345                 :            : #  endif
    1346                 :            : # endif
    1347                 :            : 
    1348                 :            : #endif /* Use misc. or use GNU.  */
    1349                 :            : 
    1350                 :            : #ifndef _FORCE_INLINES
    1351                 :            : # undef __STRING_INLINE
    1352                 :            : #endif
    1353                 :            : 
    1354                 :            : #endif /* No string inlines.  */

Generated by: LCOV version 1.9