Don't cache the result of __builtin_constant_p in variables, otherwise
[kopensolaris-gnu/glibc.git] / string / bits / string2.h
1 /* Machine-independant string function optimizations.
2    Copyright (C) 1997, 1998 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 Library General Public License as
8    published by the Free Software Foundation; either version 2 of the
9    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    Library General Public License for more details.
15
16    You should have received a copy of the GNU Library General Public
17    License along with the GNU C Library; see the file COPYING.LIB.  If not,
18    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19    Boston, MA 02111-1307, USA.  */
20
21 #ifndef _STRING_H
22 # error "Never use <bits/string2.h> directly; include <string.h> instead."
23 #endif
24
25 #ifndef __NO_STRING_INLINES
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 later.  */
41
42 #ifdef __cplusplus
43 # define __STRING_INLINE inline
44 #else
45 # define __STRING_INLINE extern __inline
46 #endif
47
48 #if _STRING_ARCH_unaligned
49 /* If we can do unaligned memory accesses we must know the endianess.  */
50 # include <endian.h>
51 # include <bits/types.h>
52
53 # if __BYTE_ORDER == __LITTLE_ENDIAN
54 #  define __STRING2_SMALL_GET16(src, idx) \
55      (((__const unsigned char *) (__const char *) (src))[idx + 1] << 8        \
56       | ((__const unsigned char *) (__const char *) (src))[idx])
57 #  define __STRING2_SMALL_GET32(src, idx) \
58      (((((__const unsigned char *) (__const char *) (src))[idx + 3] << 8      \
59         | ((__const unsigned char *) (__const char *) (src))[idx + 2]) << 8   \
60        | ((__const unsigned char *) (__const char *) (src))[idx + 1]) << 8    \
61       | ((__const unsigned char *) (__const char *) (src))[idx])
62 # else
63 #  define __STRING2_SMALL_GET16(src, idx) \
64      (((__const unsigned char *) (__const char *) (src))[idx] << 8            \
65       | ((__const unsigned char *) (__const char *) (src))[idx + 1])
66 #  define __STRING2_SMALL_GET32(src, idx) \
67      (((((__const unsigned char *) (__const char *) (src))[idx] << 8          \
68         | ((__const unsigned char *) (__const char *) (src))[idx + 1]) << 8   \
69        | ((__const unsigned char *) (__const char *) (src))[idx + 2]) << 8    \
70       | ((__const unsigned char *) (__const char *) (src))[idx + 3])
71 # endif
72 #else
73 /* These are a few types we need for the optimizations if we cannot
74    use unaligned memory accesses.  */
75 # define __STRING2_COPY_TYPE(N) \
76   typedef struct { unsigned char __arr[N]; }                                  \
77     __STRING2_COPY_ARR##N __attribute__ ((packed))
78 __STRING2_COPY_TYPE (2);
79 __STRING2_COPY_TYPE (3);
80 __STRING2_COPY_TYPE (4);
81 __STRING2_COPY_TYPE (5);
82 __STRING2_COPY_TYPE (6);
83 __STRING2_COPY_TYPE (7);
84 __STRING2_COPY_TYPE (8);
85 # undef __STRING2_COPY_TYPE
86 #endif
87
88 /* Dereferencing a pointer arg to run sizeof on it fails for the void
89    pointer case, so we use this instead.
90    Note that __x is evaluated twice. */
91 #define __string2_1bptr_p(__x) \
92   ((size_t)(const void *)((__x) + 1) - (size_t)(const void *)(__x) == 1)
93
94 /* Set N bytes of S to C.  */
95 #ifndef _HAVE_STRING_ARCH_memset
96 # define memset(s, c, n) \
97   (__extension__ (__builtin_constant_p (c) && (c) == '\0'                     \
98                   ? ({ void *__s = (s); __bzero (__s, n); __s; })             \
99                   : memset (s, c, n)))
100 #endif
101
102
103 /* Copy N bytes from SRC to DEST, returning pointer to byte following the
104    last copied.  */
105 #ifdef __USE_GNU
106 # ifndef _HAVE_STRING_ARCH_mempcpy
107 #  define __mempcpy(dest, src, n) \
108   (__extension__ (__builtin_constant_p (src) && __builtin_constant_p (n)      \
109                   && __string2_1bptr_p (src) && n <= 8                        \
110                   ? __mempcpy_small (dest, __mempcpy_args (src), n)           \
111                   : __mempcpy (dest, src, n)))
112 /* In glibc we use this function frequently but for namespace reasons
113    we have to use the name `__mempcpy'.  */
114 #  define mempcpy(dest, src, n) __mempcpy (dest, src, n)
115
116 #  if _STRING_ARCH_unaligned
117 #   define __mempcpy_args(src) \
118      ((char *) (src))[0], ((char *) (src))[2], ((char *) (src))[4],           \
119      ((char *) (src))[6],                                                     \
120      __extension__ __STRING2_SMALL_GET16 (src, 0),                            \
121      __extension__ __STRING2_SMALL_GET16 (src, 4),                            \
122      __extension__ __STRING2_SMALL_GET32 (src, 0),                            \
123      __extension__ __STRING2_SMALL_GET32 (src, 4)
124 __STRING_INLINE void *__mempcpy_small (void *, char, char, char, char,
125                                        __uint16_t, __uint16_t, __uint32_t,
126                                        __uint32_t, size_t);
127 __STRING_INLINE void *
128 __mempcpy_small (void *__dest1,
129                  char __src0_1, char __src2_1, char __src4_1, char __src6_1,
130                  __uint16_t __src0_2, __uint16_t __src4_2,
131                  __uint32_t __src0_4, __uint32_t __src4_4,
132                  size_t __srclen)
133 {
134   char *__dest = (char *) __dest1;
135   switch (__srclen)
136     {
137     case 1:
138       *__dest++ = __src0_1;
139       break;
140     case 2:
141       *((__uint16_t *) __dest) = __src0_2;
142       __dest += 2;
143       break;
144     case 3:
145       *((__uint16_t *) __dest) = __src0_2;
146       __dest += 2;
147       *__dest++ = __src2_1;
148       break;
149     case 4:
150       *((__uint32_t *) __dest) = __src0_4;
151       __dest += 4;
152       break;
153     case 5:
154       *((__uint32_t *) __dest) = __src0_4;
155       __dest += 4;
156       *__dest++ = __src4_1;
157       break;
158     case 6:
159       *((__uint32_t *) __dest) = __src0_4;
160       *((__uint16_t *) (__dest + 4)) = __src4_2;
161       __dest += 6;
162       break;
163     case 7:
164       *((__uint32_t *) __dest) = __src0_4;
165       *((__uint16_t *) (__dest + 4)) = __src4_2;
166       __dest += 6;
167       *__dest++ = __src6_1;
168       break;
169     case 8:
170       *((__uint32_t *) __dest) = __src0_4;
171       *((__uint32_t *) (__dest + 4)) = __src4_4;
172       __dest += 8;
173       break;
174     }
175   return (void *) __dest;
176 }
177 #  else
178 #   define __mempcpy_args(src) \
179      ((__const char *) (src))[0],                                             \
180      __extension__ ((__STRING2_COPY_ARR2)                                     \
181       { { ((__const char *) (src))[0], ((__const char *) (src))[1] } }),      \
182      __extension__ ((__STRING2_COPY_ARR3)                                     \
183       { { ((__const char *) (src))[0], ((__const char *) (src))[1],           \
184           ((__const char *) (src))[2] } }),                                   \
185      __extension__ ((__STRING2_COPY_ARR4)                                     \
186       { { ((__const char *) (src))[0], ((__const char *) (src))[1],           \
187           ((__const char *) (src))[2], ((__const char *) (src))[3] } }),      \
188      __extension__ ((__STRING2_COPY_ARR5)                                     \
189       { { ((__const char *) (src))[0], ((__const char *) (src))[1],           \
190           ((__const char *) (src))[2], ((__const char *) (src))[3],           \
191           ((__const char *) (src))[4] } }),                                   \
192      __extension__ ((__STRING2_COPY_ARR6)                                     \
193       { { ((__const char *) (src))[0], ((__const char *) (src))[1],           \
194           ((__const char *) (src))[2], ((__const char *) (src))[3],           \
195           ((__const char *) (src))[4], ((__const char *) (src))[5] } }),      \
196      __extension__ ((__STRING2_COPY_ARR7)                                     \
197       { { ((__const char *) (src))[0], ((__const char *) (src))[1],           \
198           ((__const char *) (src))[2], ((__const char *) (src))[3],           \
199           ((__const char *) (src))[4], ((__const char *) (src))[5],           \
200           ((__const char *) (src))[6] } }),                                   \
201      __extension__ ((__STRING2_COPY_ARR8)                                     \
202       { { ((__const char *) (src))[0], ((__const char *) (src))[1],           \
203           ((__const char *) (src))[2], ((__const char *) (src))[3],           \
204           ((__const char *) (src))[4], ((__const char *) (src))[5],           \
205           ((__const char *) (src))[6], ((__const char *) (src))[7] } })
206 __STRING_INLINE void *__mempcpy_small (void *, char, __STRING2_COPY_ARR2,
207                                        __STRING2_COPY_ARR3,
208                                        __STRING2_COPY_ARR4,
209                                        __STRING2_COPY_ARR5,
210                                        __STRING2_COPY_ARR6,
211                                        __STRING2_COPY_ARR7,
212                                        __STRING2_COPY_ARR8, size_t);
213 __STRING_INLINE void *
214 __mempcpy_small (void *__dest1, char __src1,
215                  __STRING2_COPY_ARR2 __src2, __STRING2_COPY_ARR3 __src3,
216                  __STRING2_COPY_ARR4 __src4, __STRING2_COPY_ARR5 __src5,
217                  __STRING2_COPY_ARR6 __src6, __STRING2_COPY_ARR7 __src7,
218                  __STRING2_COPY_ARR8 __src8, size_t __srclen)
219 {
220   char *__dest = (char *) __dest1;
221   switch (__srclen)
222     {
223     case 1:
224       *__dest = __src1;
225       break;
226     case 2:
227       __extension__ *((__STRING2_COPY_ARR2 *) __dest) = __src2;
228       break;
229     case 3:
230       __extension__ *((__STRING2_COPY_ARR3 *) __dest) = __src3;
231       break;
232     case 4:
233       __extension__ *((__STRING2_COPY_ARR4 *) __dest) = __src4;
234       break;
235     case 5:
236       __extension__ *((__STRING2_COPY_ARR5 *) __dest) = __src5;
237       break;
238     case 6:
239       __extension__ *((__STRING2_COPY_ARR6 *) __dest) = __src6;
240       break;
241     case 7:
242       __extension__ *((__STRING2_COPY_ARR7 *) __dest) = __src7;
243       break;
244     case 8:
245       __extension__ *((__STRING2_COPY_ARR8 *) __dest) = __src8;
246       break;
247     }
248   return (void *) (__dest + __srclen);
249 }
250 #  endif
251 # endif
252 #endif
253
254
255 /* Copy SRC to DEST.  */
256 #ifndef _HAVE_STRING_ARCH_strcpy
257 # define strcpy(dest, src) \
258   (__extension__ (__builtin_constant_p (src)                                  \
259                   ? (__string2_1bptr_p (src) && strlen (src) + 1 <= 8         \
260                      ? __strcpy_small (dest, __strcpy_args (src),             \
261                                        strlen (src) + 1)                      \
262                      : (char *) memcpy (dest, src, strlen (src) + 1))         \
263                   : strcpy (dest, src)))
264
265 # if _STRING_ARCH_unaligned
266 #  define __strcpy_args(src) \
267      __extension__ __STRING2_SMALL_GET16 (src, 0),                            \
268      __extension__ __STRING2_SMALL_GET16 (src, 4),                            \
269      __extension__ __STRING2_SMALL_GET32 (src, 0),                            \
270      __extension__ __STRING2_SMALL_GET32 (src, 4)
271 __STRING_INLINE char *__strcpy_small (char *, __uint16_t, __uint16_t,
272                                       __uint32_t, __uint32_t, size_t);
273 __STRING_INLINE char *
274 __strcpy_small (char *__dest,
275                 __uint16_t __src0_2, __uint16_t __src4_2,
276                 __uint32_t __src0_4, __uint32_t __src4_4,
277                 size_t __srclen)
278 {
279   switch (__srclen)
280     {
281     case 1:
282       *__dest = '\0';
283       break;
284     case 2:
285       *((__uint16_t *) __dest) = __src0_2;
286       break;
287     case 3:
288       *((__uint16_t *) __dest) = __src0_2;
289       *(__dest + 2) = '\0';
290       break;
291     case 4:
292       *((__uint32_t *) __dest) = __src0_4;
293       break;
294     case 5:
295       *((__uint32_t *) __dest) = __src0_4;
296       *(__dest + 4) = '\0';
297       break;
298     case 6:
299       *((__uint32_t *) __dest) = __src0_4;
300       *((__uint16_t *) (__dest + 4)) = __src4_2;
301       break;
302     case 7:
303       *((__uint32_t *) __dest) = __src0_4;
304       *((__uint16_t *) (__dest + 4)) = __src4_2;
305       *(__dest + 6) = '\0';
306       break;
307     case 8:
308       *((__uint32_t *) __dest) = __src0_4;
309       *((__uint32_t *) (__dest + 4)) = __src4_4;
310       break;
311     }
312   return __dest;
313 }
314 # else
315 #  define __strcpy_args(src) \
316      __extension__ ((__STRING2_COPY_ARR2)                                     \
317       { { ((__const char *) (src))[0], '\0' } }),                             \
318      __extension__ ((__STRING2_COPY_ARR3)                                     \
319       { { ((__const char *) (src))[0], ((__const char *) (src))[1],           \
320           '\0' } }),                                                          \
321      __extension__ ((__STRING2_COPY_ARR4)                                     \
322       { { ((__const char *) (src))[0], ((__const char *) (src))[1],           \
323           ((__const char *) (src))[2], '\0' } }),                             \
324      __extension__ ((__STRING2_COPY_ARR5)                                     \
325       { { ((__const char *) (src))[0], ((__const char *) (src))[1],           \
326           ((__const char *) (src))[2], ((__const char *) (src))[3],           \
327           '\0' } }),                                                          \
328      __extension__ ((__STRING2_COPY_ARR6)                                     \
329       { { ((__const char *) (src))[0], ((__const char *) (src))[1],           \
330           ((__const char *) (src))[2], ((__const char *) (src))[3],           \
331           ((__const char *) (src))[4], '\0' } }),                             \
332      __extension__ ((__STRING2_COPY_ARR7)                                     \
333       { { ((__const char *) (src))[0], ((__const char *) (src))[1],           \
334           ((__const char *) (src))[2], ((__const char *) (src))[3],           \
335           ((__const char *) (src))[4], ((__const char *) (src))[5],           \
336           '\0' } }),                                                          \
337      __extension__ ((__STRING2_COPY_ARR8)                                     \
338       { { ((__const char *) (src))[0], ((__const char *) (src))[1],           \
339           ((__const char *) (src))[2], ((__const char *) (src))[3],           \
340           ((__const char *) (src))[4], ((__const char *) (src))[5],           \
341           ((__const char *) (src))[6], '\0' } })
342 __STRING_INLINE char *__strcpy_small (char *, __STRING2_COPY_ARR2,
343                                       __STRING2_COPY_ARR3,
344                                       __STRING2_COPY_ARR4,
345                                       __STRING2_COPY_ARR5,
346                                       __STRING2_COPY_ARR6,
347                                       __STRING2_COPY_ARR7,
348                                       __STRING2_COPY_ARR8, size_t);
349 __STRING_INLINE char *
350 __strcpy_small (char *__dest,
351                 __STRING2_COPY_ARR2 __src2, __STRING2_COPY_ARR3 __src3,
352                 __STRING2_COPY_ARR4 __src4, __STRING2_COPY_ARR5 __src5,
353                 __STRING2_COPY_ARR6 __src6, __STRING2_COPY_ARR7 __src7,
354                 __STRING2_COPY_ARR8 __src8, size_t __srclen)
355 {
356   switch (__srclen)
357     {
358     case 1:
359       *__dest = '\0';
360       break;
361     case 2:
362       __extension__ *((__STRING2_COPY_ARR2 *) __dest) = __src2;
363       break;
364     case 3:
365       __extension__ *((__STRING2_COPY_ARR3 *) __dest) = __src3;
366       break;
367     case 4:
368       __extension__ *((__STRING2_COPY_ARR4 *) __dest) = __src4;
369       break;
370     case 5:
371       __extension__ *((__STRING2_COPY_ARR5 *) __dest) = __src5;
372       break;
373     case 6:
374       __extension__ *((__STRING2_COPY_ARR6 *) __dest) = __src6;
375       break;
376     case 7:
377       __extension__ *((__STRING2_COPY_ARR7 *) __dest) = __src7;
378       break;
379     case 8:
380       __extension__ *((__STRING2_COPY_ARR8 *) __dest) = __src8;
381       break;
382   }
383   return __dest;
384 }
385 # endif
386 #endif
387
388
389 /* Copy SRC to DEST, returning pointer to final NUL byte.  */
390 #ifdef __USE_GNU
391 # ifndef _HAVE_STRING_ARCH_stpcpy
392 #  define __stpcpy(dest, src) \
393   (__extension__ (__builtin_constant_p (src)                                  \
394                   ? (__string2_1bptr_p (src) && strlen (src) + 1 <= 8         \
395                      ? __stpcpy_small (dest, __stpcpy_args (src),             \
396                                        strlen (src) + 1)                      \
397                      : ((char *) __mempcpy (dest, src, strlen (src) + 1) - 1))\
398                   : __stpcpy (dest, src)))
399 /* In glibc we use this function frequently but for namespace reasons
400    we have to use the name `__stpcpy'.  */
401 #  define stpcpy(dest, src) __stpcpy (dest, src)
402
403 #  if _STRING_ARCH_unaligned
404 #   define __stpcpy_args(src) \
405      __extension__ __STRING2_SMALL_GET16 (src, 0),                            \
406      __extension__ __STRING2_SMALL_GET16 (src, 4),                            \
407      __extension__ __STRING2_SMALL_GET32 (src, 0),                            \
408      __extension__ __STRING2_SMALL_GET32 (src, 4)
409 __STRING_INLINE char *__stpcpy_small (char *, __uint16_t, __uint16_t,
410                                       __uint32_t, __uint32_t, size_t);
411 __STRING_INLINE char *
412 __stpcpy_small (char *__dest,
413                 __uint16_t __src0_2, __uint16_t __src4_2,
414                 __uint32_t __src0_4, __uint32_t __src4_4,
415                 size_t __srclen)
416 {
417   switch (__srclen)
418     {
419     case 1:
420       *__dest = '\0';
421       break;
422     case 2:
423       *((__uint16_t *) __dest) = __src0_2;
424       ++__dest;
425       break;
426     case 3:
427       *((__uint16_t *) __dest) = __src0_2;
428       __dest += sizeof (__uint16_t);
429       *__dest = '\0';
430       break;
431     case 4:
432       *((__uint32_t *) __dest) = __src0_4;
433       __dest += 3;
434       break;
435     case 5:
436       *((__uint32_t *) __dest) = __src0_4;
437       __dest += 4;
438       *__dest = '\0';
439       break;
440     case 6:
441       *((__uint32_t *) __dest) = __src0_4;
442       *((__uint16_t *) (__dest + 4)) = __src4_2;
443       __dest += 5;
444       break;
445     case 7:
446       *((__uint32_t *) __dest) = __src0_4;
447       *((__uint16_t *) (__dest + 4)) = __src4_2;
448       __dest += 6;
449       *__dest = '\0';
450       break;
451     case 8:
452       *((__uint32_t *) __dest) = __src0_4;
453       *((__uint32_t *) (__dest + 4)) = __src4_4;
454       __dest += 7;
455       break;
456     }
457   return __dest;
458 }
459 #  else
460 #  define __stpcpy_args(src) \
461      __extension__ ((__STRING2_COPY_ARR2)                                     \
462       { { ((__const char *) (src))[0], '\0' } }),                             \
463      __extension__ ((__STRING2_COPY_ARR3)                                     \
464       { { ((__const char *) (src))[0], ((__const char *) (src))[1],           \
465           '\0' } }),                                                          \
466      __extension__ ((__STRING2_COPY_ARR4)                                     \
467       { { ((__const char *) (src))[0], ((__const char *) (src))[1],           \
468           ((__const char *) (src))[2], '\0' } }),                             \
469      __extension__ ((__STRING2_COPY_ARR5)                                     \
470       { { ((__const char *) (src))[0], ((__const char *) (src))[1],           \
471           ((__const char *) (src))[2], ((__const char *) (src))[3],           \
472           '\0' } }),                                                          \
473      __extension__ ((__STRING2_COPY_ARR6)                                     \
474       { { ((__const char *) (src))[0], ((__const char *) (src))[1],           \
475           ((__const char *) (src))[2], ((__const char *) (src))[3],           \
476           ((__const char *) (src))[4], '\0' } }),                             \
477      __extension__ ((__STRING2_COPY_ARR7)                                     \
478       { { ((__const char *) (src))[0], ((__const char *) (src))[1],           \
479           ((__const char *) (src))[2], ((__const char *) (src))[3],           \
480           ((__const char *) (src))[4], ((__const char *) (src))[5],           \
481           '\0' } }),                                                          \
482      __extension__ ((__STRING2_COPY_ARR8)                                     \
483       { { ((__const char *) (src))[0], ((__const char *) (src))[1],           \
484           ((__const char *) (src))[2], ((__const char *) (src))[3],           \
485           ((__const char *) (src))[4], ((__const char *) (src))[5],           \
486           ((__const char *) (src))[6], '\0' } })
487 __STRING_INLINE char *__stpcpy_small (char *, __STRING2_COPY_ARR2,
488                                       __STRING2_COPY_ARR3,
489                                       __STRING2_COPY_ARR4,
490                                       __STRING2_COPY_ARR5,
491                                       __STRING2_COPY_ARR6,
492                                       __STRING2_COPY_ARR7,
493                                       __STRING2_COPY_ARR8, size_t);
494 __STRING_INLINE char *
495 __stpcpy_small (char *__dest,
496                 __STRING2_COPY_ARR2 __src2, __STRING2_COPY_ARR3 __src3,
497                 __STRING2_COPY_ARR4 __src4, __STRING2_COPY_ARR5 __src5,
498                 __STRING2_COPY_ARR6 __src6, __STRING2_COPY_ARR7 __src7,
499                 __STRING2_COPY_ARR8 __src8, size_t __srclen)
500 {
501   switch (__srclen)
502     {
503     case 1:
504       *__dest = '\0';
505       break;
506     case 2:
507       __extension__ *((__STRING2_COPY_ARR2 *) __dest) = __src2;
508       break;
509     case 3:
510       __extension__ *((__STRING2_COPY_ARR3 *) __dest) = __src3;
511       break;
512     case 4:
513       __extension__ *((__STRING2_COPY_ARR4 *) __dest) = __src4;
514       break;
515     case 5:
516       __extension__ *((__STRING2_COPY_ARR5 *) __dest) = __src5;
517       break;
518     case 6:
519       __extension__ *((__STRING2_COPY_ARR6 *) __dest) = __src6;
520       break;
521     case 7:
522       __extension__ *((__STRING2_COPY_ARR7 *) __dest) = __src7;
523       break;
524     case 8:
525       __extension__ *((__STRING2_COPY_ARR8 *) __dest) = __src8;
526       break;
527   }
528   return __dest + __srclen - 1;
529 }
530 #  endif
531 # endif
532 #endif
533
534
535 /* Copy no more than N characters of SRC to DEST.  */
536 #ifndef _HAVE_STRING_ARCH_strncpy
537 # if defined _HAVE_STRING_ARCH_memset && defined _HAVE_STRING_ARCH_mempcpy
538 #  define strncpy(dest, src, n) \
539   (__extension__ ({ char *__dest = (dest);                                    \
540                     __builtin_constant_p (src) && __builtin_constant_p (n)    \
541                     ? (strlen (src) + 1 >= ((size_t) (n))                     \
542                        ? (char *) memcpy (__dest, src, n)                     \
543                        : (memset (__mempcpy (__dest, src, strlen (src)),      \
544                                   '\0', n - strlen (src)),                    \
545                           __dest))                                            \
546                     : strncpy (__dest, src, n); }))
547 # else
548 #  define strncpy(dest, src, n) \
549   (__extension__ (__builtin_constant_p (src) && __builtin_constant_p (n)      \
550                   ? (strlen (src) + 1 >= ((size_t) (n))                       \
551                      ? (char *) memcpy (dest, src, n)                         \
552                      : strncpy (dest, src, n))                                \
553                   : strncpy (dest, src, n)))
554 # endif
555 #endif
556
557
558 /* Append no more than N characters from SRC onto DEST.  */
559 #ifndef _HAVE_STRING_ARCH_strncat
560 # ifdef _HAVE_STRING_ARCH_strchr
561 #  define strncat(dest, src, n) \
562   (__extension__ ({ char *__dest = (dest);                                    \
563                     __builtin_constant_p (src) && __builtin_constant_p (n)    \
564                     ? (strlen (src) < ((size_t) (n))                          \
565                        ? strcat (__dest, src)                                 \
566                        : (memcpy (strchr (__dest, '\0'), src, n), __dest))    \
567                     : strncat (dest, src, n); }))
568 # else
569 #  define strncat(dest, src, n) \
570   (__extension__ (__builtin_constant_p (src) && __builtin_constant_p (n)      \
571                   ? (strlen (src) < ((size_t) (n))                            \
572                      ? strcat (dest, src)                                     \
573                      : strncat (dest, src, n))                                \
574                   : strncat (dest, src, n)))
575 # endif
576 #endif
577
578
579 /* Compare characters of S1 and S2.  */
580 #ifndef _HAVE_STRING_ARCH_strcmp
581 # define strcmp(s1, s2) \
582   __extension__                                                               \
583   ({ size_t __s1_len, __s2_len;                                               \
584      (__builtin_constant_p (s1) && __builtin_constant_p (s2)                  \
585       && (__s1_len = strlen (s1), __s2_len = strlen (s2),                     \
586           (!__string2_1bptr_p (s1) || __s1_len >= 4)                          \
587           && (!__string2_1bptr_p (s2) || __s2_len >= 4))                      \
588       ? memcmp ((__const char *) (s1), (__const char *) (s2),                 \
589                 (__s1_len < __s2_len ? __s1_len : __s2_len) + 1)              \
590       : (__builtin_constant_p (s1) && __string2_1bptr_p (s1)                  \
591          && (__s1_len = strlen (s1), __s1_len < 4)                            \
592          ? (__builtin_constant_p (s2) && __string2_1bptr_p (s2)               \
593             ? __strcmp_cc (s1, s2, __s1_len)                                  \
594             : __strcmp_cg (s1, s2, __s1_len))                                 \
595          : (__builtin_constant_p (s2) && __string2_1bptr_p (s2)               \
596             && (__s2_len = strlen (s2), __s2_len < 4)                         \
597             ? (__builtin_constant_p (s1) && __string2_1bptr_p (s1)            \
598                ? __strcmp_cc (s1, s2, __s2_len)                               \
599                : __strcmp_gc (s1, s2, __s2_len))                              \
600             : strcmp (s1, s2)))); })
601
602 # define __strcmp_cc(s1, s2, l) \
603   (__extension__ ({ register int __result =                                   \
604                       (((__const unsigned char *) (__const char *) (s1))[0]   \
605                        - ((__const unsigned char *) (__const char *)(s2))[0]);\
606                     if (l > 0 && __result == 0)                               \
607                       {                                                       \
608                         __result = (((__const unsigned char *)                \
609                                      (__const char *) (s1))[1]                \
610                                     - ((__const unsigned char *)              \
611                                        (__const char *) (s2))[1]);            \
612                         if (l > 1 && __result == 0)                           \
613                           {                                                   \
614                             __result =                                        \
615                               (((__const unsigned char *)                     \
616                                 (__const char *) (s1))[2]                     \
617                                - ((__const unsigned char *)                   \
618                                   (__const char *) (s2))[2]);                 \
619                             if (l > 2 && __result == 0)                       \
620                               __result =                                      \
621                                 (((__const unsigned char *)                   \
622                                   (__const char *) (s1))[3]                   \
623                                  - ((__const unsigned char *)                 \
624                                     (__const char *) (s2))[3]);               \
625                           }                                                   \
626                       }                                                       \
627                     __result; }))
628
629 # define __strcmp_cg(s1, s2, l1) \
630   (__extension__ ({ __const unsigned char *__s2 =                             \
631                       (__const unsigned char *) (__const char *) (s2);        \
632                     register int __result =                                   \
633                       (((__const unsigned char *) (__const char *) (s1))[0]   \
634                        - __s2[0]);                                            \
635                     if (l1 > 0 && __result == 0)                              \
636                       {                                                       \
637                         __result = (((__const unsigned char *)                \
638                                      (__const char *) (s1))[1] - __s2[1]);    \
639                         if (l1 > 1 && __result == 0)                          \
640                           {                                                   \
641                             __result = (((__const unsigned char *)            \
642                                          (__const char *) (s1))[2] - __s2[2]);\
643                             if (l1 > 2 && __result == 0)                      \
644                               __result = (((__const unsigned char *)          \
645                                           (__const char *)  (s1))[3]          \
646                                           - __s2[3]);                         \
647                           }                                                   \
648                       }                                                       \
649                     __result; }))
650
651 # define __strcmp_gc(s1, s2, l2) \
652   (__extension__ ({ __const unsigned char *__s1 =                             \
653                       (__const unsigned char *) (__const char *) (s1);        \
654                     register int __result =                                   \
655                       __s1[0] - ((__const unsigned char *)                    \
656                                  (__const char *) (s2))[0];                   \
657                     if (l2 > 0 && __result == 0)                              \
658                       {                                                       \
659                         __result = (__s1[1]                                   \
660                                     - ((__const unsigned char *)              \
661                                        (__const char *) (s2))[1]);            \
662                         if (l2 > 1 && __result == 0)                          \
663                           {                                                   \
664                             __result =                                        \
665                               (__s1[2] - ((__const unsigned char *)           \
666                                           (__const char *) (s2))[2]);         \
667                             if (l2 > 2 && __result == 0)                      \
668                               __result =                                      \
669                                 (__s1[3]                                      \
670                                  - ((__const unsigned char *)                 \
671                                     (__const char *) (s2))[3]);               \
672                           }                                                   \
673                       }                                                       \
674                     __result; }))
675 #endif
676
677
678 /* Compare N characters of S1 and S2.  */
679 #ifndef _HAVE_STRING_ARCH_strncmp
680 # define strncmp(s1, s2, n) \
681   (__extension__ (__builtin_constant_p (s1) && strlen (s1) < ((size_t) (n))   \
682                   ? strcmp (s1, s2)                                           \
683                   : (__builtin_constant_p (s2) && strlen (s2) < ((size_t) (n))\
684                      ? strcmp (s1, s2)                                        \
685                      : strncmp (s1, s2, n))))
686 #endif
687
688
689 /* Return the length of the initial segment of S which
690    consists entirely of characters not in REJECT.  */
691 #ifndef _HAVE_STRING_ARCH_strcspn
692 # define strcspn(s, reject) \
693   __extension__                                                               \
694   ({ char __r0, __r1, __r2;                                                   \
695      (__builtin_constant_p (reject) && __string2_1bptr_p (reject)             \
696       ? ((__r0 = ((__const char *) (reject))[0], __r0 == '\0')                \
697          ? strlen (s)                                                         \
698          : ((__r1 = ((__const char *) (reject))[1], __r1 == '\0')             \
699             ? __strcspn_c1 (s, __r0)                                          \
700             : ((__r2 = ((__const char *) (reject))[2], __r2 == '\0')          \
701                ? __strcspn_c2 (s, __r0, __r1)                                 \
702                : (((__const char *) (reject))[3] == '\0'                      \
703                   ? __strcspn_c3 (s, __r0, __r1, __r2)                        \
704                   : strcspn (s, reject)))))                                   \
705                   : strcspn (s, reject)); })
706
707 __STRING_INLINE size_t __strcspn_c1 (__const char *__s, char __reject);
708 __STRING_INLINE size_t
709 __strcspn_c1 (__const char *__s, char __reject)
710 {
711   register size_t __result = 0;
712   while (__s[__result] != '\0' && __s[__result] != __reject)
713     ++__result;
714   return __result;
715 }
716
717 __STRING_INLINE size_t __strcspn_c2 (__const char *__s, char __reject1,
718                                      char __reject2);
719 __STRING_INLINE size_t
720 __strcspn_c2 (__const char *__s, char __reject1, char __reject2)
721 {
722   register size_t __result = 0;
723   while (__s[__result] != '\0' && __s[__result] != __reject1
724          && __s[__result] != __reject2)
725     ++__result;
726   return __result;
727 }
728
729 __STRING_INLINE size_t __strcspn_c3 (__const char *__s, char __reject1,
730                                      char __reject2, char __reject3);
731 __STRING_INLINE size_t
732 __strcspn_c3 (__const char *__s, char __reject1, char __reject2,
733               char __reject3)
734 {
735   register size_t __result = 0;
736   while (__s[__result] != '\0' && __s[__result] != __reject1
737          && __s[__result] != __reject2 && __s[__result] != __reject3)
738     ++__result;
739   return __result;
740 }
741 #endif
742
743
744 /* Return the length of the initial segment of S which
745    consists entirely of characters in ACCEPT.  */
746 #ifndef _HAVE_STRING_ARCH_strspn
747 # define strspn(s, accept) \
748   __extension__                                                               \
749   ({ char __a0, __a1, __a2;                                                   \
750      (__builtin_constant_p (accept) && __string2_1bptr_p (accept)             \
751       ? ((__a0 = ((__const char *) (accept))[0], __a0 == '\0')                \
752          ? 0                                                                  \
753          : ((__a1 = ((__const char *) (accept))[1], __a1 == '\0')             \
754             ? __strspn_c1 (s, __a0)                                           \
755             : ((__a2 = ((__const char *) (accept))[2], __a2 == '\0')          \
756                ? __strspn_c2 (s, __a0, __a1)                                  \
757                : (((__const char *) (accept))[3] == '\0'                      \
758                   ? __strspn_c3 (s, __a0, __a1, __a2)                         \
759                   : strspn (s, accept)))))                                    \
760       : strspn (s, accept)); })
761
762 __STRING_INLINE size_t __strspn_c1 (__const char *__s, char __accept);
763 __STRING_INLINE size_t
764 __strspn_c1 (__const char *__s, char __accept)
765 {
766   register size_t __result = 0;
767   /* Please note that __accept never can be '\0'.  */
768   while (__s[__result] == __accept)
769     ++__result;
770   return __result;
771 }
772
773 __STRING_INLINE size_t __strspn_c2 (__const char *__s, char __accept1,
774                                     char __accept2);
775 __STRING_INLINE size_t
776 __strspn_c2 (__const char *__s, char __accept1, char __accept2)
777 {
778   register size_t __result = 0;
779   /* Please note that __accept1 and __accept2 never can be '\0'.  */
780   while (__s[__result] == __accept1 || __s[__result] == __accept2)
781     ++__result;
782   return __result;
783 }
784
785 __STRING_INLINE size_t __strspn_c3 (__const char *__s, char __accept1,
786                                     char __accept2, char __accept3);
787 __STRING_INLINE size_t
788 __strspn_c3 (__const char *__s, char __accept1, char __accept2, char __accept3)
789 {
790   register size_t __result = 0;
791   /* Please note that __accept1 to __accept3 never can be '\0'.  */
792   while (__s[__result] == __accept1 || __s[__result] == __accept2
793          || __s[__result] == __accept3)
794     ++__result;
795   return __result;
796 }
797 #endif
798
799
800 /* Find the first occurrence in S of any character in ACCEPT.  */
801 #ifndef _HAVE_STRING_ARCH_strpbrk
802 # define strpbrk(s, accept) \
803   __extension__                                                               \
804   ({ char __a0, __a1, __a2;                                                   \
805      (__builtin_constant_p (accept) && __string2_1bptr_p (accept)             \
806       ? ((__a0 = ((__const char  *) (accept))[0], __a0 == '\0')               \
807          ? NULL                                                               \
808          : ((__a1 = ((__const char *) (accept))[1], __a1 == '\0')             \
809             ? strchr (s, __a0)                                                \
810             : ((__a2 = ((__const char *) (accept))[2], __a2 == '\0')          \
811                ? __strpbrk_c2 (s, __a0, __a1)                                 \
812                : (((__const char *) (accept))[3] == '\0'                      \
813                   ? __strpbrk_c3 (s, __a0, __a1, __a2)                        \
814                   : strpbrk (s, accept)))))                                   \
815       : strpbrk (s, accept)); })
816
817 __STRING_INLINE char *__strpbrk_c2 (__const char *__s, char __accept1,
818                                      char __accept2);
819 __STRING_INLINE char *
820 __strpbrk_c2 (__const char *__s, char __accept1, char __accept2)
821 {
822   /* Please note that __accept1 and __accept2 never can be '\0'.  */
823   while (*__s != '\0' && *__s != __accept1 && *__s != __accept2)
824     ++__s;
825   return *__s == '\0' ? NULL : (char *) __s;
826 }
827
828 __STRING_INLINE char *__strpbrk_c3 (__const char *__s, char __accept1,
829                                      char __accept2, char __accept3);
830 __STRING_INLINE char *
831 __strpbrk_c3 (__const char *__s, char __accept1, char __accept2,
832               char __accept3)
833 {
834   /* Please note that __accept1 to __accept3 never can be '\0'.  */
835   while (*__s != '\0' && *__s != __accept1 && *__s != __accept2
836          && *__s != __accept3)
837     ++__s;
838   return *__s == '\0' ? NULL : (char *) __s;
839 }
840 #endif
841
842
843 /* Find the first occurrence of NEEDLE in HAYSTACK.  */
844 #ifndef _HAVE_STRING_ARCH_strstr
845 # define strstr(haystack, needle) \
846   (__extension__ (__builtin_constant_p (needle) && __string2_1bptr_p (needle) \
847                   ? (((__const char *) (needle))[0] == '\0'                   \
848                      ? (char *) (haystack)                                    \
849                      : (((__const char *) (needle))[1] == '\0'                \
850                         ? strchr (haystack,                                   \
851                                   ((__const char *) (needle))[0])             \
852                         : strstr (haystack, needle)))                         \
853                   : strstr (haystack, needle)))
854 #endif
855
856
857 #ifdef __USE_GNU
858 # ifndef _HAVE_STRING_ARCH_strnlen
859 __STRING_INLINE size_t strnlen (__const char *__string, size_t __maxlen);
860 __STRING_INLINE size_t
861 strnlen (__const char *__string, size_t __maxlen)
862 {
863   __const char *__end = (__const char *) memchr (__string, '\0', __maxlen);
864   return __end ? __end - __string : __maxlen;
865 }
866 # endif
867 #endif
868
869
870 #ifndef _HAVE_STRING_ARCH_strtok_r
871 # define __strtok_r(s, sep, nextp) \
872   (__extension__ (__builtin_constant_p (sep) && __string2_1bptr_p (sep)       \
873                   ? (((__const char *) (sep))[0] != '\0'                      \
874                      && ((__const char *) (sep))[1] == '\0'                   \
875                      ? __strtok_r_1c (s, ((__const char *) (sep))[0], nextp)  \
876                      : __strtok_r (s, sep, nextp))                            \
877                   : __strtok_r (s, sep, nextp)))
878
879 __STRING_INLINE char *__strtok_r_1c (char *__s, char __sep, char **__nextp);
880 __STRING_INLINE char *
881 __strtok_r_1c (char *__s, char __sep, char **__nextp)
882 {
883   char *__result;
884   if (__s == NULL)
885     __s = *__nextp;
886   while (*__s == __sep)
887     ++__s;
888   if (*__s == '\0')
889     __result = NULL;
890   else
891     {
892       __result = __s;
893       while (*__s != '\0' && *__s != __sep)
894         ++__s;
895       if (*__s == '\0')
896         *__nextp = __s;
897       else
898         {
899           *__s = '\0';
900           *__nextp = __s + 1;
901         }
902     }
903   return __result;
904 }
905 # if defined __USE_POSIX || defined __USE_MISC
906 #  define strtok_r(s, sep, nextp) __strtok_r ((s), (sep), (nextp))
907 # endif
908 #endif
909
910
911 #ifndef _HAVE_STRING_ARCH_strsep
912
913 # define __strsep(s, reject) \
914   __extension__                                                               \
915   ({ char __r0, __r1, __r2;                                                   \
916      (__builtin_constant_p (reject) && __string2_1bptr_p (reject)             \
917       && (__r0 = ((__const char *) (reject))[0], __r0 != '\0')                \
918       ? ((__r1 = ((__const char *) (reject))[1], __r1 == '\0')                \
919          ? __strsep_1c (s, __r0)                                              \
920          : ((__r2 = ((__const char *) (reject))[2], __r2 == '\0')             \
921             ? __strsep_2c (s, __r0, __r1)                                     \
922             : (((__const char *) (reject))[3] == '\0'                         \
923                ? __strsep_3c (s, __r0, __r1, __r2)                            \
924                : __strsep_g (s, reject))))                                    \
925       : __strsep_g (s, reject)); })
926
927 __STRING_INLINE char *__strsep_1c (char **__s, char __reject);
928 __STRING_INLINE char *
929 __strsep_1c (char **__s, char __reject)
930 {
931   register char *__retval = *__s;
932   if (__retval == NULL)
933     return *__s = NULL;
934   if (*__retval == __reject)
935     *(*__s)++ = '\0';
936   else
937     if ((*__s = strchr (__retval, __reject)) != NULL)
938       *(*__s)++ = '\0';
939     else
940       *__s = NULL;
941   return __retval;
942 }
943
944 __STRING_INLINE char *__strsep_2c (char **__s, char __reject1, char __reject2);
945 __STRING_INLINE char *
946 __strsep_2c (char **__s, char __reject1, char __reject2)
947 {
948   register char *__retval = *__s;
949   if (__retval == NULL)
950     return *__s = NULL;
951   if (*__retval == __reject1 || *__retval == __reject2)
952     *(*__s)++ = '\0';
953   else
954     {
955       register char *__cp = __retval;
956       while (*__cp != '\0' && *__cp != __reject1 && *__cp != __reject2)
957         ++__cp;
958       if (*__cp != '\0')
959         {
960           *__s = __cp;
961           *(*__s)++ = '\0';
962         }
963       else
964         *__s = NULL;
965     }
966   return __retval;
967 }
968
969 __STRING_INLINE char *__strsep_3c (char **__s, char __reject1, char __reject2,
970                                    char __reject3);
971 __STRING_INLINE char *
972 __strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
973 {
974   register char *__retval = *__s;
975   if (__retval == NULL)
976     return *__s = NULL;
977   if (*__retval == __reject1 || *__retval == __reject2
978       || *__retval == __reject3)
979     *(*__s)++ = '\0';
980   else
981     {
982       register char *__cp = __retval;
983       while (*__cp != '\0' && *__cp != __reject1 && *__cp != __reject2
984              && *__cp != __reject3)
985         ++__cp;
986       if (*__cp != '\0')
987         {
988           *__s = __cp;
989           *(*__s)++ = '\0';
990         }
991       else
992         *__s = NULL;
993     }
994   return __retval;
995 }
996
997 __STRING_INLINE char *__strsep_g (char **__s, __const char *__reject);
998 __STRING_INLINE char *
999 __strsep_g (char **__s, __const char *__reject)
1000 {
1001   register char *__retval = *__s;
1002   if (__retval == NULL || *__retval == '\0')
1003     return NULL;
1004   if ((*__s = strpbrk (__retval, __reject)) != NULL)
1005     *(*__s)++ = '\0';
1006   return __retval;
1007 }
1008 # ifdef __USE_BSD
1009 #  define strsep(s, reject) __strsep ((s), (reject))
1010 # endif
1011 #endif
1012
1013 /* We need the memory allocation functions for inline strdup().
1014    Referring to stdlib.h (even minimally) is not allowed if
1015    __STRICT_ANSI__. */
1016 #ifndef __STRICT_ANSI__
1017
1018 #if !defined _HAVE_STRING_ARCH_strdup || !defined _HAVE_STRING_ARCH_strndup
1019 # define __need_malloc_and_calloc
1020 # include <stdlib.h>
1021 #endif
1022
1023 #ifndef _HAVE_STRING_ARCH_strdup
1024
1025 # define __strdup(s) \
1026   (__extension__ (__builtin_constant_p (s) && __string2_1bptr_p (s)           \
1027                   ? (((__const char *) (s))[0] == '\0'                        \
1028                      ? (char *) calloc (1, 1)                                 \
1029                      : ({ size_t __len = strlen (s) + 1;                      \
1030                           char *__retval = (char *) malloc (__len);           \
1031                           if (__retval != NULL)                               \
1032                             __retval = (char *) memcpy (__retval, s, __len);  \
1033                           __retval; }))                                       \
1034                   : __strdup (s)))
1035
1036 # if defined __USE_SVID || defined __USE_BSD || defined __USE_XOPEN_EXTENDED
1037 #  define strdup(s) __strdup (s)
1038 # endif
1039 #endif
1040
1041 #ifndef _HAVE_STRING_ARCH_strndup
1042
1043 # define __strndup(s, n) \
1044   (__extension__ (__builtin_constant_p (s) && __string2_1bptr_p (s)           \
1045                   ? (((__const char *) (s))[0] == '\0'                        \
1046                      ? (char *) calloc (1, 1)                                 \
1047                      : ({ size_t __len = strlen (s) + 1;                      \
1048                           size_t __n = (n);                                   \
1049                           char *__retval;                                     \
1050                           if (__n < __len)                                    \
1051                             __len = __n;                                      \
1052                           __retval = (char *) malloc (__len);                 \
1053                           if (__retval != NULL)                               \
1054                             {                                                 \
1055                               __retval[__len - 1] = '\0';                     \
1056                               __retval = (char *) memcpy (__retval, s,        \
1057                                                           __len - 1);         \
1058                             }                                                 \
1059                           __retval; }))                                       \
1060                   : __strndup ((s), (n))))
1061
1062 # ifdef __GNU_SOURCE
1063 #  define strndup(s, n) __strndup ((s), (n))
1064 # endif
1065 #endif
1066
1067 #endif /* Strict ANSI */
1068
1069 #undef __STRING_INLINE
1070
1071 #endif /* No string inlines.  */