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