File Coverage

/usr/include/x86_64-linux-gnu/bits/string2.h

Criterion	Covered	Total	%
statement	0	3	0.0
branch			n/a
condition			n/a
subroutine			n/a
total	0	3	0.0

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