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