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