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