string/bits/string2.h

   1 /* Machine-independant string function optimizations.
   2    Copyright (C) 1997-2016 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, see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef _STRING_H
  21 # error "Never use <bits/string2.h> directly; include <string.h> instead."
  22 #endif
  23
  24 #ifndef __NO_STRING_INLINES
  25
  26 /* Unlike the definitions in the header <bits/string.h> the
  27    definitions contained here are not optimized down to assembler
  28    level.  Those optimizations are not always a good idea since this
  29    means the code size increases a lot.  Instead the definitions here
  30    optimize some functions in a way which do not dramatically
  31    increase the code size and which do not use assembler.  The main
  32    trick is to use GCC's `__builtin_constant_p' function.
  33
  34    Every function XXX which has a defined version in
  35    <bits/string.h> must be accompanied by a symbol _HAVE_STRING_ARCH_XXX
  36    to make sure we don't get redefinitions.
  37
  38    We must use here macros instead of inline functions since the
  39    trick won't work with the latter.  */
  40
  41 #ifndef __STRING_INLINE
  42 # ifdef __cplusplus
  43 #  define __STRING_INLINE inline
  44 # else
  45 #  define __STRING_INLINE __extern_inline
  46 # endif
  47 #endif
  48
  49 /* Dereferencing a pointer arg to run sizeof on it fails for the void
  50    pointer case, so we use this instead.
  51    Note that __x is evaluated twice. */
  52 #define __string2_1bptr_p(__x) \
  53   ((size_t)(const void *)((__x) + 1) - (size_t)(const void *)(__x) == 1)
  54
  55 /* Set N bytes of S to C.  */
  56 #if !defined _HAVE_STRING_ARCH_memset
  57 # define __bzero(s, n) __builtin_memset (s, '\0', n)
  58 #endif
  59
  60
  61 #ifndef _HAVE_STRING_ARCH_strchr
  62 extern void *__rawmemchr (const void *__s, int __c);
  63 #  define strchr(s, c) \
  64   (__extension__ (__builtin_constant_p (c) && !__builtin_constant_p (s)       \
  65                   && (c) == '\0'                                              \
  66                   ? (char *) __rawmemchr (s, c)                               \
  67                   : __builtin_strchr (s, c)))
  68 #endif
  69
  70
  71 /* Copy SRC to DEST, returning pointer to final NUL byte.  */
  72 #ifdef __USE_GNU
  73 # ifndef _HAVE_STRING_ARCH_stpcpy
  74 #  define __stpcpy(dest, src) __builtin_stpcpy (dest, src)
  75 /* In glibc we use this function frequently but for namespace reasons
  76    we have to use the name `__stpcpy'.  */
  77 #  define stpcpy(dest, src) __stpcpy (dest, src)
  78 # endif
  79 #endif
  80
  81
  82 /* Copy no more than N characters of SRC to DEST.  */
  83 #ifndef _HAVE_STRING_ARCH_strncpy
  84 # define strncpy(dest, src, n) __builtin_strncpy (dest, src, n)
  85 #endif
  86
  87
  88 /* Append no more than N characters from SRC onto DEST.  */
  89 #ifndef _HAVE_STRING_ARCH_strncat
  90 # ifdef _USE_STRING_ARCH_strchr
  91 #  define strncat(dest, src, n) \
  92   (__extension__ ({ char *__dest = (dest);                                    \
  93                     __builtin_constant_p (src) && __builtin_constant_p (n)    \
  94                     ? (strlen (src) < ((size_t) (n))                          \
  95                        ? strcat (__dest, src)                                 \
  96                        : (*((char *) __mempcpy (strchr (__dest, '\0'),        \
  97                                                 src, n)) = '\0', __dest))     \
  98                     : strncat (dest, src, n); }))
  99 # else
 100 #  define strncat(dest, src, n) __builtin_strncat (dest, src, n)
 101 # endif
 102 #endif
 103
 104
 105 /* Compare characters of S1 and S2.  */
 106 #ifndef _HAVE_STRING_ARCH_strcmp
 107 # define strcmp(s1, s2) \
 108   __extension__                                                               \
 109   ({ size_t __s1_len, __s2_len;                                               \
 110      (__builtin_constant_p (s1) && __builtin_constant_p (s2)                  \
 111       && (__s1_len = strlen (s1), __s2_len = strlen (s2),                     \
 112           (!__string2_1bptr_p (s1) || __s1_len >= 4)                          \
 113           && (!__string2_1bptr_p (s2) || __s2_len >= 4))                      \
 114       ? __builtin_strcmp (s1, s2)                                             \
 115       : (__builtin_constant_p (s1) && __string2_1bptr_p (s1)                  \
 116          && (__s1_len = strlen (s1), __s1_len < 4)                            \
 117          ? (__builtin_constant_p (s2) && __string2_1bptr_p (s2)               \
 118             ? __builtin_strcmp (s1, s2)                                       \
 119             : __strcmp_cg (s1, s2, __s1_len))                                 \
 120          : (__builtin_constant_p (s2) && __string2_1bptr_p (s2)               \
 121             && (__s2_len = strlen (s2), __s2_len < 4)                         \
 122             ? (__builtin_constant_p (s1) && __string2_1bptr_p (s1)            \
 123                ? __builtin_strcmp (s1, s2)                                    \
 124                : -__strcmp_cg (s2, s1, __s2_len))                             \
 125             : __builtin_strcmp (s1, s2)))); })
 126
 127 # define __strcmp_cg(s1, s2, l1) \
 128   (__extension__ ({ const unsigned char *__s2 =                               \
 129                       (const unsigned char *) (const char *) (s2);            \
 130                     int __result =                                            \
 131                       (((const unsigned char *) (const char *) (s1))[0]       \
 132                        - __s2[0]);                                            \
 133                     if (l1 > 0 && __result == 0)                              \
 134                       {                                                       \
 135                         __result = (((const unsigned char *)                  \
 136                                      (const char *) (s1))[1] - __s2[1]);      \
 137                         if (l1 > 1 && __result == 0)                          \
 138                           {                                                   \
 139                             __result = (((const unsigned char *)              \
 140                                          (const char *) (s1))[2] - __s2[2]);  \
 141                             if (l1 > 2 && __result == 0)                      \
 142                               __result = (((const unsigned char *)            \
 143                                           (const char *)  (s1))[3]            \
 144                                           - __s2[3]);                         \
 145                           }                                                   \
 146                       }                                                       \
 147                     __result; }))
 148 #endif
 149
 150
 151 /* Compare N characters of S1 and S2.  */
 152 #ifndef _HAVE_STRING_ARCH_strncmp
 153 # define strncmp(s1, s2, n)                                                   \
 154   (__extension__ (__builtin_constant_p (n)                                    \
 155                   && ((__builtin_constant_p (s1)                              \
 156                        && strlen (s1) < ((size_t) (n)))                       \
 157                       || (__builtin_constant_p (s2)                           \
 158                           && strlen (s2) < ((size_t) (n))))                   \
 159                   ? strcmp (s1, s2) : strncmp (s1, s2, n)))
 160 #endif
 161
 162
 163 /* Return the length of the initial segment of S which
 164    consists entirely of characters not in REJECT.  */
 165 #ifndef _HAVE_STRING_ARCH_strcspn
 166 # define strcspn(s, reject) __builtin_strcspn (s, reject)
 167 #endif
 168
 169
 170 /* Return the length of the initial segment of S which
 171    consists entirely of characters in ACCEPT.  */
 172 #ifndef _HAVE_STRING_ARCH_strspn
 173 # define strspn(s, accept) __builtin_strspn (s, accept)
 174 #endif
 175
 176
 177 /* Find the first occurrence in S of any character in ACCEPT.  */
 178 #ifndef _HAVE_STRING_ARCH_strpbrk
 179 # define strpbrk(s, accept) __builtin_strpbrk (s, accept)
 180 #endif
 181
 182
 183 #if !defined _HAVE_STRING_ARCH_strtok_r || defined _FORCE_INLINES
 184 # ifndef _HAVE_STRING_ARCH_strtok_r
 185 #  define __strtok_r(s, sep, nextp) \
 186   (__extension__ (__builtin_constant_p (sep) && __string2_1bptr_p (sep)       \
 187                   && ((const char *) (sep))[0] != '\0'                        \
 188                   && ((const char *) (sep))[1] == '\0'                        \
 189                   ? __strtok_r_1c (s, ((const char *) (sep))[0], nextp)       \
 190                   : __strtok_r (s, sep, nextp)))
 191 # endif
 192
 193 __STRING_INLINE char *__strtok_r_1c (char *__s, char __sep, char **__nextp);
 194 __STRING_INLINE char *
 195 __strtok_r_1c (char *__s, char __sep, char **__nextp)
 196 {
 197   char *__result;
 198   if (__s == NULL)
 199     __s = *__nextp;
 200   while (*__s == __sep)
 201     ++__s;
 202   __result = NULL;
 203   if (*__s != '\0')
 204     {
 205       __result = __s++;
 206       while (*__s != '\0')
 207         if (*__s++ == __sep)
 208           {
 209             __s[-1] = '\0';
 210             break;
 211           }
 212     }
 213   *__nextp = __s;
 214   return __result;
 215 }
 216 # ifdef __USE_POSIX
 217 #  define strtok_r(s, sep, nextp) __strtok_r (s, sep, nextp)
 218 # endif
 219 #endif
 220
 221
 222 #if !defined _HAVE_STRING_ARCH_strsep || defined _FORCE_INLINES
 223 # ifndef _HAVE_STRING_ARCH_strsep
 224
 225 extern char *__strsep_g (char **__stringp, const char *__delim);
 226 #  define __strsep(s, reject) \
 227   __extension__                                                               \
 228   ({ char __r0, __r1, __r2;                                                   \
 229      (__builtin_constant_p (reject) && __string2_1bptr_p (reject)             \
 230       && (__r0 = ((const char *) (reject))[0],                                \
 231           ((const char *) (reject))[0] != '\0')                               \
 232       ? ((__r1 = ((const char *) (reject))[1],                                \
 233          ((const char *) (reject))[1] == '\0')                                \
 234          ? __strsep_1c (s, __r0)                                              \
 235          : ((__r2 = ((const char *) (reject))[2], __r2 == '\0')               \
 236             ? __strsep_2c (s, __r0, __r1)                                     \
 237             : (((const char *) (reject))[3] == '\0'                           \
 238                ? __strsep_3c (s, __r0, __r1, __r2)                            \
 239                : __strsep_g (s, reject))))                                    \
 240       : __strsep_g (s, reject)); })
 241 # endif
 242
 243 __STRING_INLINE char *__strsep_1c (char **__s, char __reject);
 244 __STRING_INLINE char *
 245 __strsep_1c (char **__s, char __reject)
 246 {
 247   char *__retval = *__s;
 248   if (__retval != NULL && (*__s = strchr (__retval, __reject)) != NULL)
 249     *(*__s)++ = '\0';
 250   return __retval;
 251 }
 252
 253 __STRING_INLINE char *__strsep_2c (char **__s, char __reject1, char __reject2);
 254 __STRING_INLINE char *
 255 __strsep_2c (char **__s, char __reject1, char __reject2)
 256 {
 257   char *__retval = *__s;
 258   if (__retval != NULL)
 259     {
 260       char *__cp = __retval;
 261       while (1)
 262         {
 263           if (*__cp == '\0')
 264             {
 265               __cp = NULL;
 266           break;
 267             }
 268           if (*__cp == __reject1 || *__cp == __reject2)
 269             {
 270               *__cp++ = '\0';
 271               break;
 272             }
 273           ++__cp;
 274         }
 275       *__s = __cp;
 276     }
 277   return __retval;
 278 }
 279
 280 __STRING_INLINE char *__strsep_3c (char **__s, char __reject1, char __reject2,
 281                                    char __reject3);
 282 __STRING_INLINE char *
 283 __strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
 284 {
 285   char *__retval = *__s;
 286   if (__retval != NULL)
 287     {
 288       char *__cp = __retval;
 289       while (1)
 290         {
 291           if (*__cp == '\0')
 292             {
 293               __cp = NULL;
 294           break;
 295             }
 296           if (*__cp == __reject1 || *__cp == __reject2 || *__cp == __reject3)
 297             {
 298               *__cp++ = '\0';
 299               break;
 300             }
 301           ++__cp;
 302         }
 303       *__s = __cp;
 304     }
 305   return __retval;
 306 }
 307 # ifdef __USE_MISC
 308 #  define strsep(s, reject) __strsep (s, reject)
 309 # endif
 310 #endif
 311
 312 /* We need the memory allocation functions for inline strdup().
 313    Referring to stdlib.h (even minimally) is not allowed
 314    in any of the tight standards compliant modes.  */
 315 #ifdef __USE_MISC
 316
 317 # if !defined _HAVE_STRING_ARCH_strdup || !defined _HAVE_STRING_ARCH_strndup
 318 #  define __need_malloc_and_calloc
 319 #  include <stdlib.h>
 320 # endif
 321
 322 # ifndef _HAVE_STRING_ARCH_strdup
 323
 324 extern char *__strdup (const char *__string) __THROW __attribute_malloc__;
 325 #  define __strdup(s) \
 326   (__extension__ (__builtin_constant_p (s) && __string2_1bptr_p (s)           \
 327                   ? (((const char *) (s))[0] == '\0'                          \
 328                      ? (char *) calloc ((size_t) 1, (size_t) 1)               \
 329                      : ({ size_t __len = strlen (s) + 1;                      \
 330                           char *__retval = (char *) malloc (__len);           \
 331                           if (__retval != NULL)                               \
 332                             __retval = (char *) memcpy (__retval, s, __len);  \
 333                           __retval; }))                                       \
 334                   : __strdup (s)))
 335
 336 #  if defined __USE_XOPEN_EXTENDED || defined __USE_XOPEN2K8
 337 #   define strdup(s) __strdup (s)
 338 #  endif
 339 # endif
 340
 341 # ifndef _HAVE_STRING_ARCH_strndup
 342
 343 extern char *__strndup (const char *__string, size_t __n)
 344      __THROW __attribute_malloc__;
 345 #  define __strndup(s, n) \
 346   (__extension__ (__builtin_constant_p (s) && __string2_1bptr_p (s)           \
 347                   ? (((const char *) (s))[0] == '\0'                          \
 348                      ? (char *) calloc ((size_t) 1, (size_t) 1)               \
 349                      : ({ size_t __len = strlen (s) + 1;                      \
 350                           size_t __n = (n);                                   \
 351                           char *__retval;                                     \
 352                           if (__n < __len)                                    \
 353                             __len = __n + 1;                                  \
 354                           __retval = (char *) malloc (__len);                 \
 355                           if (__retval != NULL)                               \
 356                             {                                                 \
 357                               __retval[__len - 1] = '\0';                     \
 358                               __retval = (char *) memcpy (__retval, s,        \
 359                                                           __len - 1);         \
 360                             }                                                 \
 361                           __retval; }))                                       \
 362                   : __strndup (s, n)))
 363
 364 #  ifdef __USE_XOPEN2K8
 365 #   define strndup(s, n) __strndup (s, n)
 366 #  endif
 367 # endif
 368
 369 #endif /* Use misc. or use GNU.  */
 370
 371 #ifndef _FORCE_INLINES
 372 # undef __STRING_INLINE
 373 #endif
 374
 375 #endif /* No string inlines.  */