1/* Copyright (C) 1991-2017 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, see
16 <http://www.gnu.org/licenses/>. */
17
18/*
19 * ISO C99 Standard: 7.21 String handling <string.h>
20 */
21
22#ifndef _STRING_H
23#define _STRING_H 1
24
25#define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION
26#include <bits/libc-header-start.h>
27
28__BEGIN_DECLS
29
30/* Get size_t and NULL from <stddef.h>. */
31#define __need_size_t
32#define __need_NULL
33#include <stddef.h>
34
35/* Tell the caller that we provide correct C++ prototypes. */
36#if defined __cplusplus && __GNUC_PREREQ (4, 4)
37# define __CORRECT_ISO_CPP_STRING_H_PROTO
38#endif
39
40
41__BEGIN_NAMESPACE_STD
42/* Copy N bytes of SRC to DEST. */
43extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
44 size_t __n) __THROW __nonnull ((1, 2));
45/* Copy N bytes of SRC to DEST, guaranteeing
46 correct behavior for overlapping strings. */
47extern void *memmove (void *__dest, const void *__src, size_t __n)
48 __THROW __nonnull ((1, 2));
49__END_NAMESPACE_STD
50
51/* Copy no more than N bytes of SRC to DEST, stopping when C is found.
52 Return the position in DEST one byte past where C was copied,
53 or NULL if C was not found in the first N bytes of SRC. */
54#if defined __USE_MISC || defined __USE_XOPEN
55extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
56 int __c, size_t __n)
57 __THROW __nonnull ((1, 2));
58#endif /* Misc || X/Open. */
59
60
61__BEGIN_NAMESPACE_STD
62/* Set N bytes of S to C. */
63extern void *memset (void *__s, int __c, size_t __n) __THROW __nonnull ((1));
64
65/* Compare N bytes of S1 and S2. */
66extern int memcmp (const void *__s1, const void *__s2, size_t __n)
67 __THROW __attribute_pure__ __nonnull ((1, 2));
68
69/* Search N bytes of S for C. */
70#ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
71extern "C++"
72{
73extern void *memchr (void *__s, int __c, size_t __n)
74 __THROW __asm ("memchr") __attribute_pure__ __nonnull ((1));
75extern const void *memchr (const void *__s, int __c, size_t __n)
76 __THROW __asm ("memchr") __attribute_pure__ __nonnull ((1));
77
78# ifdef __OPTIMIZE__
79__extern_always_inline void *
80memchr (void *__s, int __c, size_t __n) __THROW
81{
82 return __builtin_memchr (__s, __c, __n);
83}
84
85__extern_always_inline const void *
86memchr (const void *__s, int __c, size_t __n) __THROW
87{
88 return __builtin_memchr (__s, __c, __n);
89}
90# endif
91}
92#else
93extern void *memchr (const void *__s, int __c, size_t __n)
94 __THROW __attribute_pure__ __nonnull ((1));
95#endif
96__END_NAMESPACE_STD
97
98#ifdef __USE_GNU
99/* Search in S for C. This is similar to `memchr' but there is no
100 length limit. */
101# ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
102extern "C++" void *rawmemchr (void *__s, int __c)
103 __THROW __asm ("rawmemchr") __attribute_pure__ __nonnull ((1));
104extern "C++" const void *rawmemchr (const void *__s, int __c)
105 __THROW __asm ("rawmemchr") __attribute_pure__ __nonnull ((1));
106# else
107extern void *rawmemchr (const void *__s, int __c)
108 __THROW __attribute_pure__ __nonnull ((1));
109# endif
110
111/* Search N bytes of S for the final occurrence of C. */
112# ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
113extern "C++" void *memrchr (void *__s, int __c, size_t __n)
114 __THROW __asm ("memrchr") __attribute_pure__ __nonnull ((1));
115extern "C++" const void *memrchr (const void *__s, int __c, size_t __n)
116 __THROW __asm ("memrchr") __attribute_pure__ __nonnull ((1));
117# else
118extern void *memrchr (const void *__s, int __c, size_t __n)
119 __THROW __attribute_pure__ __nonnull ((1));
120# endif
121#endif
122
123
124__BEGIN_NAMESPACE_STD
125/* Copy SRC to DEST. */
126extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
127 __THROW __nonnull ((1, 2));
128/* Copy no more than N characters of SRC to DEST. */
129extern char *strncpy (char *__restrict __dest,
130 const char *__restrict __src, size_t __n)
131 __THROW __nonnull ((1, 2));
132
133/* Append SRC onto DEST. */
134extern char *strcat (char *__restrict __dest, const char *__restrict __src)
135 __THROW __nonnull ((1, 2));
136/* Append no more than N characters from SRC onto DEST. */
137extern char *strncat (char *__restrict __dest, const char *__restrict __src,
138 size_t __n) __THROW __nonnull ((1, 2));
139
140/* Compare S1 and S2. */
141extern int strcmp (const char *__s1, const char *__s2)
142 __THROW __attribute_pure__ __nonnull ((1, 2));
143/* Compare N characters of S1 and S2. */
144extern int strncmp (const char *__s1, const char *__s2, size_t __n)
145 __THROW __attribute_pure__ __nonnull ((1, 2));
146
147/* Compare the collated forms of S1 and S2. */
148extern int strcoll (const char *__s1, const char *__s2)
149 __THROW __attribute_pure__ __nonnull ((1, 2));
150/* Put a transformation of SRC into no more than N bytes of DEST. */
151extern size_t strxfrm (char *__restrict __dest,
152 const char *__restrict __src, size_t __n)
153 __THROW __nonnull ((2));
154__END_NAMESPACE_STD
155
156#ifdef __USE_XOPEN2K8
157# include <xlocale.h>
158
159/* Compare the collated forms of S1 and S2, using sorting rules from L. */
160extern int strcoll_l (const char *__s1, const char *__s2, __locale_t __l)
161 __THROW __attribute_pure__ __nonnull ((1, 2, 3));
162/* Put a transformation of SRC into no more than N bytes of DEST,
163 using sorting rules from L. */
164extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
165 __locale_t __l) __THROW __nonnull ((2, 4));
166#endif
167
168#if (defined __USE_XOPEN_EXTENDED || defined __USE_XOPEN2K8 \
169 || __GLIBC_USE (LIB_EXT2))
170/* Duplicate S, returning an identical malloc'd string. */
171extern char *strdup (const char *__s)
172 __THROW __attribute_malloc__ __nonnull ((1));
173#endif
174
175/* Return a malloc'd copy of at most N bytes of STRING. The
176 resultant string is terminated even if no null terminator
177 appears before STRING[N]. */
178#if defined __USE_XOPEN2K8 || __GLIBC_USE (LIB_EXT2)
179extern char *strndup (const char *__string, size_t __n)
180 __THROW __attribute_malloc__ __nonnull ((1));
181#endif
182
183#if defined __USE_GNU && defined __GNUC__
184/* Duplicate S, returning an identical alloca'd string. */
185# define strdupa(s) \
186 (__extension__ \
187 ({ \
188 const char *__old = (s); \
189 size_t __len = strlen (__old) + 1; \
190 char *__new = (char *) __builtin_alloca (__len); \
191 (char *) memcpy (__new, __old, __len); \
192 }))
193
194/* Return an alloca'd copy of at most N bytes of string. */
195# define strndupa(s, n) \
196 (__extension__ \
197 ({ \
198 const char *__old = (s); \
199 size_t __len = strnlen (__old, (n)); \
200 char *__new = (char *) __builtin_alloca (__len + 1); \
201 __new[__len] = '\0'; \
202 (char *) memcpy (__new, __old, __len); \
203 }))
204#endif
205
206__BEGIN_NAMESPACE_STD
207/* Find the first occurrence of C in S. */
208#ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
209extern "C++"
210{
211extern char *strchr (char *__s, int __c)
212 __THROW __asm ("strchr") __attribute_pure__ __nonnull ((1));
213extern const char *strchr (const char *__s, int __c)
214 __THROW __asm ("strchr") __attribute_pure__ __nonnull ((1));
215
216# ifdef __OPTIMIZE__
217__extern_always_inline char *
218strchr (char *__s, int __c) __THROW
219{
220 return __builtin_strchr (__s, __c);
221}
222
223__extern_always_inline const char *
224strchr (const char *__s, int __c) __THROW
225{
226 return __builtin_strchr (__s, __c);
227}
228# endif
229}
230#else
231extern char *strchr (const char *__s, int __c)
232 __THROW __attribute_pure__ __nonnull ((1));
233#endif
234/* Find the last occurrence of C in S. */
235#ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
236extern "C++"
237{
238extern char *strrchr (char *__s, int __c)
239 __THROW __asm ("strrchr") __attribute_pure__ __nonnull ((1));
240extern const char *strrchr (const char *__s, int __c)
241 __THROW __asm ("strrchr") __attribute_pure__ __nonnull ((1));
242
243# ifdef __OPTIMIZE__
244__extern_always_inline char *
245strrchr (char *__s, int __c) __THROW
246{
247 return __builtin_strrchr (__s, __c);
248}
249
250__extern_always_inline const char *
251strrchr (const char *__s, int __c) __THROW
252{
253 return __builtin_strrchr (__s, __c);
254}
255# endif
256}
257#else
258extern char *strrchr (const char *__s, int __c)
259 __THROW __attribute_pure__ __nonnull ((1));
260#endif
261__END_NAMESPACE_STD
262
263#ifdef __USE_GNU
264/* This function is similar to `strchr'. But it returns a pointer to
265 the closing NUL byte in case C is not found in S. */
266# ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
267extern "C++" char *strchrnul (char *__s, int __c)
268 __THROW __asm ("strchrnul") __attribute_pure__ __nonnull ((1));
269extern "C++" const char *strchrnul (const char *__s, int __c)
270 __THROW __asm ("strchrnul") __attribute_pure__ __nonnull ((1));
271# else
272extern char *strchrnul (const char *__s, int __c)
273 __THROW __attribute_pure__ __nonnull ((1));
274# endif
275#endif
276
277__BEGIN_NAMESPACE_STD
278/* Return the length of the initial segment of S which
279 consists entirely of characters not in REJECT. */
280extern size_t strcspn (const char *__s, const char *__reject)
281 __THROW __attribute_pure__ __nonnull ((1, 2));
282/* Return the length of the initial segment of S which
283 consists entirely of characters in ACCEPT. */
284extern size_t strspn (const char *__s, const char *__accept)
285 __THROW __attribute_pure__ __nonnull ((1, 2));
286/* Find the first occurrence in S of any character in ACCEPT. */
287#ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
288extern "C++"
289{
290extern char *strpbrk (char *__s, const char *__accept)
291 __THROW __asm ("strpbrk") __attribute_pure__ __nonnull ((1, 2));
292extern const char *strpbrk (const char *__s, const char *__accept)
293 __THROW __asm ("strpbrk") __attribute_pure__ __nonnull ((1, 2));
294
295# ifdef __OPTIMIZE__
296__extern_always_inline char *
297strpbrk (char *__s, const char *__accept) __THROW
298{
299 return __builtin_strpbrk (__s, __accept);
300}
301
302__extern_always_inline const char *
303strpbrk (const char *__s, const char *__accept) __THROW
304{
305 return __builtin_strpbrk (__s, __accept);
306}
307# endif
308}
309#else
310extern char *strpbrk (const char *__s, const char *__accept)
311 __THROW __attribute_pure__ __nonnull ((1, 2));
312#endif
313/* Find the first occurrence of NEEDLE in HAYSTACK. */
314#ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
315extern "C++"
316{
317extern char *strstr (char *__haystack, const char *__needle)
318 __THROW __asm ("strstr") __attribute_pure__ __nonnull ((1, 2));
319extern const char *strstr (const char *__haystack, const char *__needle)
320 __THROW __asm ("strstr") __attribute_pure__ __nonnull ((1, 2));
321
322# ifdef __OPTIMIZE__
323__extern_always_inline char *
324strstr (char *__haystack, const char *__needle) __THROW
325{
326 return __builtin_strstr (__haystack, __needle);
327}
328
329__extern_always_inline const char *
330strstr (const char *__haystack, const char *__needle) __THROW
331{
332 return __builtin_strstr (__haystack, __needle);
333}
334# endif
335}
336#else
337extern char *strstr (const char *__haystack, const char *__needle)
338 __THROW __attribute_pure__ __nonnull ((1, 2));
339#endif
340
341
342/* Divide S into tokens separated by characters in DELIM. */
343extern char *strtok (char *__restrict __s, const char *__restrict __delim)
344 __THROW __nonnull ((2));
345__END_NAMESPACE_STD
346
347/* Divide S into tokens separated by characters in DELIM. Information
348 passed between calls are stored in SAVE_PTR. */
349extern char *__strtok_r (char *__restrict __s,
350 const char *__restrict __delim,
351 char **__restrict __save_ptr)
352 __THROW __nonnull ((2, 3));
353#ifdef __USE_POSIX
354extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
355 char **__restrict __save_ptr)
356 __THROW __nonnull ((2, 3));
357#endif
358
359#ifdef __USE_GNU
360/* Similar to `strstr' but this function ignores the case of both strings. */
361# ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
362extern "C++" char *strcasestr (char *__haystack, const char *__needle)
363 __THROW __asm ("strcasestr") __attribute_pure__ __nonnull ((1, 2));
364extern "C++" const char *strcasestr (const char *__haystack,
365 const char *__needle)
366 __THROW __asm ("strcasestr") __attribute_pure__ __nonnull ((1, 2));
367# else
368extern char *strcasestr (const char *__haystack, const char *__needle)
369 __THROW __attribute_pure__ __nonnull ((1, 2));
370# endif
371#endif
372
373#ifdef __USE_GNU
374/* Find the first occurrence of NEEDLE in HAYSTACK.
375 NEEDLE is NEEDLELEN bytes long;
376 HAYSTACK is HAYSTACKLEN bytes long. */
377extern void *memmem (const void *__haystack, size_t __haystacklen,
378 const void *__needle, size_t __needlelen)
379 __THROW __attribute_pure__ __nonnull ((1, 3));
380
381/* Copy N bytes of SRC to DEST, return pointer to bytes after the
382 last written byte. */
383extern void *__mempcpy (void *__restrict __dest,
384 const void *__restrict __src, size_t __n)
385 __THROW __nonnull ((1, 2));
386extern void *mempcpy (void *__restrict __dest,
387 const void *__restrict __src, size_t __n)
388 __THROW __nonnull ((1, 2));
389#endif
390
391
392__BEGIN_NAMESPACE_STD
393/* Return the length of S. */
394extern size_t strlen (const char *__s)
395 __THROW __attribute_pure__ __nonnull ((1));
396__END_NAMESPACE_STD
397
398#ifdef __USE_XOPEN2K8
399/* Find the length of STRING, but scan at most MAXLEN characters.
400 If no '\0' terminator is found in that many characters, return MAXLEN. */
401extern size_t strnlen (const char *__string, size_t __maxlen)
402 __THROW __attribute_pure__ __nonnull ((1));
403#endif
404
405
406__BEGIN_NAMESPACE_STD
407/* Return a string describing the meaning of the `errno' code in ERRNUM. */
408extern char *strerror (int __errnum) __THROW;
409__END_NAMESPACE_STD
410#ifdef __USE_XOPEN2K
411/* Reentrant version of `strerror'.
412 There are 2 flavors of `strerror_r', GNU which returns the string
413 and may or may not use the supplied temporary buffer and POSIX one
414 which fills the string into the buffer.
415 To use the POSIX version, -D_XOPEN_SOURCE=600 or -D_POSIX_C_SOURCE=200112L
416 without -D_GNU_SOURCE is needed, otherwise the GNU version is
417 preferred. */
418# if defined __USE_XOPEN2K && !defined __USE_GNU
419/* Fill BUF with a string describing the meaning of the `errno' code in
420 ERRNUM. */
421# ifdef __REDIRECT_NTH
422extern int __REDIRECT_NTH (strerror_r,
423 (int __errnum, char *__buf, size_t __buflen),
424 __xpg_strerror_r) __nonnull ((2));
425# else
426extern int __xpg_strerror_r (int __errnum, char *__buf, size_t __buflen)
427 __THROW __nonnull ((2));
428# define strerror_r __xpg_strerror_r
429# endif
430# else
431/* If a temporary buffer is required, at most BUFLEN bytes of BUF will be
432 used. */
433extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
434 __THROW __nonnull ((2)) __wur;
435# endif
436#endif
437
438#ifdef __USE_XOPEN2K8
439/* Translate error number to string according to the locale L. */
440extern char *strerror_l (int __errnum, __locale_t __l) __THROW;
441#endif
442
443
444/* We define this function always since `bzero' is sometimes needed when
445 the namespace rules does not allow this. */
446extern void __bzero (void *__s, size_t __n) __THROW __nonnull ((1));
447
448#ifdef __USE_MISC
449/* Copy N bytes of SRC to DEST (like memmove, but args reversed). */
450extern void bcopy (const void *__src, void *__dest, size_t __n)
451 __THROW __nonnull ((1, 2));
452
453/* Set N bytes of S to 0. */
454extern void bzero (void *__s, size_t __n) __THROW __nonnull ((1));
455
456/* As bzero, but the compiler will not delete a call to this
457 function, even if S is dead after the call. */
458extern void explicit_bzero (void *__s, size_t __n) __THROW __nonnull ((1));
459
460/* Compare N bytes of S1 and S2 (same as memcmp). */
461extern int bcmp (const void *__s1, const void *__s2, size_t __n)
462 __THROW __attribute_pure__ __nonnull ((1, 2));
463
464/* Find the first occurrence of C in S (same as strchr). */
465# ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
466extern "C++"
467{
468extern char *index (char *__s, int __c)
469 __THROW __asm ("index") __attribute_pure__ __nonnull ((1));
470extern const char *index (const char *__s, int __c)
471 __THROW __asm ("index") __attribute_pure__ __nonnull ((1));
472
473# if defined __OPTIMIZE__ && !defined __CORRECT_ISO_CPP_STRINGS_H_PROTO
474__extern_always_inline char *
475index (char *__s, int __c) __THROW
476{
477 return __builtin_index (__s, __c);
478}
479
480__extern_always_inline const char *
481index (const char *__s, int __c) __THROW
482{
483 return __builtin_index (__s, __c);
484}
485# endif
486}
487# else
488extern char *index (const char *__s, int __c)
489 __THROW __attribute_pure__ __nonnull ((1));
490# endif
491
492/* Find the last occurrence of C in S (same as strrchr). */
493# ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
494extern "C++"
495{
496extern char *rindex (char *__s, int __c)
497 __THROW __asm ("rindex") __attribute_pure__ __nonnull ((1));
498extern const char *rindex (const char *__s, int __c)
499 __THROW __asm ("rindex") __attribute_pure__ __nonnull ((1));
500
501# if defined __OPTIMIZE__ && !defined __CORRECT_ISO_CPP_STRINGS_H_PROTO
502__extern_always_inline char *
503rindex (char *__s, int __c) __THROW
504{
505 return __builtin_rindex (__s, __c);
506}
507
508__extern_always_inline const char *
509rindex (const char *__s, int __c) __THROW
510{
511 return __builtin_rindex (__s, __c);
512}
513#endif
514}
515# else
516extern char *rindex (const char *__s, int __c)
517 __THROW __attribute_pure__ __nonnull ((1));
518# endif
519
520/* Return the position of the first bit set in I, or 0 if none are set.
521 The least-significant bit is position 1, the most-significant 32. */
522extern int ffs (int __i) __THROW __attribute__ ((__const__));
523
524/* The following two functions are non-standard but necessary for non-32 bit
525 platforms. */
526# ifdef __USE_GNU
527extern int ffsl (long int __l) __THROW __attribute__ ((__const__));
528__extension__ extern int ffsll (long long int __ll)
529 __THROW __attribute__ ((__const__));
530# endif
531
532/* Compare S1 and S2, ignoring case. */
533extern int strcasecmp (const char *__s1, const char *__s2)
534 __THROW __attribute_pure__ __nonnull ((1, 2));
535
536/* Compare no more than N chars of S1 and S2, ignoring case. */
537extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
538 __THROW __attribute_pure__ __nonnull ((1, 2));
539#endif /* Use misc. */
540
541#ifdef __USE_GNU
542/* Again versions of a few functions which use the given locale instead
543 of the global one. */
544extern int strcasecmp_l (const char *__s1, const char *__s2,
545 __locale_t __loc)
546 __THROW __attribute_pure__ __nonnull ((1, 2, 3));
547
548extern int strncasecmp_l (const char *__s1, const char *__s2,
549 size_t __n, __locale_t __loc)
550 __THROW __attribute_pure__ __nonnull ((1, 2, 4));
551#endif
552
553#ifdef __USE_MISC
554/* Return the next DELIM-delimited token from *STRINGP,
555 terminating it with a '\0', and update *STRINGP to point past it. */
556extern char *strsep (char **__restrict __stringp,
557 const char *__restrict __delim)
558 __THROW __nonnull ((1, 2));
559#endif
560
561#ifdef __USE_XOPEN2K8
562/* Return a string describing the meaning of the signal number in SIG. */
563extern char *strsignal (int __sig) __THROW;
564
565/* Copy SRC to DEST, returning the address of the terminating '\0' in DEST. */
566extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
567 __THROW __nonnull ((1, 2));
568extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
569 __THROW __nonnull ((1, 2));
570
571/* Copy no more than N characters of SRC to DEST, returning the address of
572 the last character written into DEST. */
573extern char *__stpncpy (char *__restrict __dest,
574 const char *__restrict __src, size_t __n)
575 __THROW __nonnull ((1, 2));
576extern char *stpncpy (char *__restrict __dest,
577 const char *__restrict __src, size_t __n)
578 __THROW __nonnull ((1, 2));
579#endif
580
581#ifdef __USE_GNU
582/* Compare S1 and S2 as strings holding name & indices/version numbers. */
583extern int strverscmp (const char *__s1, const char *__s2)
584 __THROW __attribute_pure__ __nonnull ((1, 2));
585
586/* Sautee STRING briskly. */
587extern char *strfry (char *__string) __THROW __nonnull ((1));
588
589/* Frobnicate N bytes of S. */
590extern void *memfrob (void *__s, size_t __n) __THROW __nonnull ((1));
591
592# ifndef basename
593/* Return the file name within directory of FILENAME. We don't
594 declare the function if the `basename' macro is available (defined
595 in <libgen.h>) which makes the XPG version of this function
596 available. */
597# ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
598extern "C++" char *basename (char *__filename)
599 __THROW __asm ("basename") __nonnull ((1));
600extern "C++" const char *basename (const char *__filename)
601 __THROW __asm ("basename") __nonnull ((1));
602# else
603extern char *basename (const char *__filename) __THROW __nonnull ((1));
604# endif
605# endif
606#endif
607
608
609#if __GNUC_PREREQ (3,4)
610# if defined __OPTIMIZE__ && !defined __OPTIMIZE_SIZE__ \
611 && !defined __NO_INLINE__ && !defined __cplusplus
612/* When using GNU CC we provide some optimized versions of selected
613 functions from this header. There are two kinds of optimizations:
614
615 - machine-dependent optimizations, most probably using inline
616 assembler code; these might be quite expensive since the code
617 size can increase significantly.
618 These optimizations are not used unless the symbol
619 __USE_STRING_INLINES
620 is defined before including this header.
621
622 - machine-independent optimizations which do not increase the
623 code size significantly and which optimize mainly situations
624 where one or more arguments are compile-time constants.
625 These optimizations are used always when the compiler is
626 taught to optimize.
627
628 One can inhibit all optimizations by defining __NO_STRING_INLINES. */
629
630/* Get the machine-dependent optimizations (if any). */
631# include <bits/string.h>
632
633/* These are generic optimizations which do not add too much inline code. */
634# include <bits/string2.h>
635# endif
636
637# if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function
638/* Functions with security checks. */
639# include <bits/string3.h>
640# endif
641#endif
642
643#if defined __USE_GNU && defined __OPTIMIZE__ \
644 && defined __extern_always_inline && __GNUC_PREREQ (3,2)
645# if !defined _FORCE_INLINES && !defined _HAVE_STRING_ARCH_mempcpy
646
647#define mempcpy(dest, src, n) __mempcpy_inline (dest, src, n)
648#define __mempcpy(dest, src, n) __mempcpy_inline (dest, src, n)
649
650__extern_always_inline void *
651__mempcpy_inline (void *__restrict __dest,
652 const void *__restrict __src, size_t __n)
653{
654 return (char *) memcpy (__dest, __src, __n) + __n;
655}
656
657# endif
658#endif
659
660__END_DECLS
661
662#endif /* string.h */
663