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