?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update.
[glibc.git] / string / bits / string2.h
blobfd431b8ece0461249e428e9e201d89bf036b2314
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. */
sources.redhat.com git mirror of glibc CVS