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