Clang Project

include/string.h
1/* Copyright (C) 1991-2016 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#include <features.h>
26
27__BEGIN_DECLS
28
29/* Get size_t and NULL from <stddef.h>.  */
30#define __need_size_t
31#define __need_NULL
32#include <stddef.h>
33
34/* Tell the caller that we provide correct C++ prototypes.  */
35#if defined __cplusplus && __GNUC_PREREQ (4, 4)
36# define __CORRECT_ISO_CPP_STRING_H_PROTO
37#endif
38
39
40__BEGIN_NAMESPACE_STD
41/* Copy N bytes of SRC to DEST.  */
42extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
43      size_t __n) __THROW __nonnull ((1, 2));
44/* Copy N bytes of SRC to DEST, guaranteeing
45   correct behavior for overlapping strings.  */
46extern void *memmove (void *__dest, const void *__src, size_t __n)
47     __THROW __nonnull ((1, 2));
48__END_NAMESPACE_STD
49
50/* Copy no more than N bytes of SRC to DEST, stopping when C is found.
51   Return the position in DEST one byte past where C was copied,
52   or NULL if C was not found in the first N bytes of SRC.  */
53#if defined __USE_MISC || defined __USE_XOPEN
54extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
55       int __c, size_t __n)
56     __THROW __nonnull ((1, 2));
57#endif /* Misc || X/Open.  */
58
59
60__BEGIN_NAMESPACE_STD
61/* Set N bytes of S to C.  */
62extern void *memset (void *__s, int __c, size_t __n) __THROW __nonnull ((1));
63
64/* Compare N bytes of S1 and S2.  */
65extern int memcmp (const void *__s1, const void *__s2, size_t __n)
66     __THROW __attribute_pure__ __nonnull ((1, 2));
67
68/* Search N bytes of S for C.  */
69#ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
70extern "C++"
71{
72extern void *memchr (void *__s, int __c, size_t __n)
73      __THROW __asm ("memchr") __attribute_pure__ __nonnull ((1));
74extern const void *memchr (const void *__s, int __c, size_t __n)
75      __THROW __asm ("memchr") __attribute_pure__ __nonnull ((1));
76
77# ifdef __OPTIMIZE__
78__extern_always_inline void *
79memchr (void *__s, int __c, size_t __n) __THROW
80{
81  return __builtin_memchr (__s, __c, __n);
82}
83
84__extern_always_inline const void *
85memchr (const void *__s, int __c, size_t __n) __THROW
86{
87  return __builtin_memchr (__s, __c, __n);
88}
89# endif
90}
91#else
92extern void *memchr (const void *__s, int __c, size_t __n)
93      __THROW __attribute_pure__ __nonnull ((1));
94#endif
95__END_NAMESPACE_STD
96
97#ifdef __USE_GNU
98/* Search in S for C.  This is similar to `memchr' but there is no
99   length limit.  */
100# ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
101extern "C++" void *rawmemchr (void *__s, int __c)
102     __THROW __asm ("rawmemchr") __attribute_pure__ __nonnull ((1));
103extern "C++" const void *rawmemchr (const void *__s, int __c)
104     __THROW __asm ("rawmemchr") __attribute_pure__ __nonnull ((1));
105# else
106extern void *rawmemchr (const void *__s, int __c)
107     __THROW __attribute_pure__ __nonnull ((1));
108# endif
109
110/* Search N bytes of S for the final occurrence of C.  */
111# ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
112extern "C++" void *memrchr (void *__s, int __c, size_t __n)
113      __THROW __asm ("memrchr") __attribute_pure__ __nonnull ((1));
114extern "C++" const void *memrchr (const void *__s, int __c, size_t __n)
115      __THROW __asm ("memrchr") __attribute_pure__ __nonnull ((1));
116# else
117extern void *memrchr (const void *__s, int __c, size_t __n)
118      __THROW __attribute_pure__ __nonnull ((1));
119# endif
120#endif
121
122
123__BEGIN_NAMESPACE_STD
124/* Copy SRC to DEST.  */
125extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
126     __THROW __nonnull ((1, 2));
127/* Copy no more than N characters of SRC to DEST.  */
128extern char *strncpy (char *__restrict __dest,
129       const char *__restrict __src, size_t __n)
130     __THROW __nonnull ((1, 2));
131
132/* Append SRC onto DEST.  */
133extern char *strcat (char *__restrict __dest, const char *__restrict __src)
134     __THROW __nonnull ((1, 2));
135/* Append no more than N characters from SRC onto DEST.  */
136extern char *strncat (char *__restrict __dest, const char *__restrict __src,
137       size_t __n) __THROW __nonnull ((1, 2));
138
139/* Compare S1 and S2.  */
140extern int strcmp (const char *__s1, const char *__s2)
141     __THROW __attribute_pure__ __nonnull ((1, 2));
142/* Compare N characters of S1 and S2.  */
143extern int strncmp (const char *__s1, const char *__s2, size_t __n)
144     __THROW __attribute_pure__ __nonnull ((1, 2));
145
146/* Compare the collated forms of S1 and S2.  */
147extern int strcoll (const char *__s1, const char *__s2)
148     __THROW __attribute_pure__ __nonnull ((1, 2));
149/* Put a transformation of SRC into no more than N bytes of DEST.  */
150extern size_t strxfrm (char *__restrict __dest,
151        const char *__restrict __src, size_t __n)
152     __THROW __nonnull ((2));
153__END_NAMESPACE_STD
154
155#ifdef __USE_XOPEN2K8
156/* The following functions are equivalent to the both above but they
157   take the locale they use for the collation as an extra argument.
158   This is not standardsized but something like will come.  */
159# include <xlocale.h>
160
161/* Compare the collated forms of S1 and S2 using rules from L.  */
162extern int strcoll_l (const char *__s1, const char *__s2, __locale_t __l)
163     __THROW __attribute_pure__ __nonnull ((1, 2, 3));
164/* Put a transformation of SRC into no more than N bytes of DEST.  */
165extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
166  __locale_t __l) __THROW __nonnull ((2, 4));
167#endif
168
169#if defined __USE_XOPEN_EXTENDED || defined __USE_XOPEN2K8
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
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/* Compare N bytes of S1 and S2 (same as memcmp).  */
457extern int bcmp (const void *__s1, const void *__s2, size_t __n)
458     __THROW __attribute_pure__ __nonnull ((1, 2));
459
460/* Find the first occurrence of C in S (same as strchr).  */
461# ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
462extern "C++"
463{
464extern char *index (char *__s, int __c)
465     __THROW __asm ("index") __attribute_pure__ __nonnull ((1));
466extern const char *index (const char *__s, int __c)
467     __THROW __asm ("index") __attribute_pure__ __nonnull ((1));
468
469#  if defined __OPTIMIZE__ && !defined __CORRECT_ISO_CPP_STRINGS_H_PROTO
470__extern_always_inline char *
471index (char *__s, int __c) __THROW
472{
473  return __builtin_index (__s, __c);
474}
475
476__extern_always_inline const char *
477index (const char *__s, int __c) __THROW
478{
479  return __builtin_index (__s, __c);
480}
481#  endif
482}
483# else
484extern char *index (const char *__s, int __c)
485     __THROW __attribute_pure__ __nonnull ((1));
486# endif
487
488/* Find the last occurrence of C in S (same as strrchr).  */
489# ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
490extern "C++"
491{
492extern char *rindex (char *__s, int __c)
493     __THROW __asm ("rindex") __attribute_pure__ __nonnull ((1));
494extern const char *rindex (const char *__s, int __c)
495     __THROW __asm ("rindex") __attribute_pure__ __nonnull ((1));
496
497#  if defined __OPTIMIZE__ && !defined __CORRECT_ISO_CPP_STRINGS_H_PROTO
498__extern_always_inline char *
499rindex (char *__s, int __c) __THROW
500{
501  return __builtin_rindex (__s, __c);
502}
503
504__extern_always_inline const char *
505rindex (const char *__s, int __c) __THROW
506{
507  return __builtin_rindex (__s, __c);
508}
509#endif
510}
511# else
512extern char *rindex (const char *__s, int __c)
513     __THROW __attribute_pure__ __nonnull ((1));
514# endif
515
516/* Return the position of the first bit set in I, or 0 if none are set.
517   The least-significant bit is position 1, the most-significant 32.  */
518extern int ffs (int __i) __THROW __attribute__ ((__const__));
519
520/* The following two functions are non-standard but necessary for non-32 bit
521   platforms.  */
522# ifdef __USE_GNU
523extern int ffsl (long int __l) __THROW __attribute__ ((__const__));
524__extension__ extern int ffsll (long long int __ll)
525     __THROW __attribute__ ((__const__));
526# endif
527
528/* Compare S1 and S2, ignoring case.  */
529extern int strcasecmp (const char *__s1, const char *__s2)
530     __THROW __attribute_pure__ __nonnull ((1, 2));
531
532/* Compare no more than N chars of S1 and S2, ignoring case.  */
533extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
534     __THROW __attribute_pure__ __nonnull ((1, 2));
535#endif /* Use misc.  */
536
537#ifdef __USE_GNU
538/* Again versions of a few functions which use the given locale instead
539   of the global one.  */
540extern int strcasecmp_l (const char *__s1, const char *__s2,
541  __locale_t __loc)
542     __THROW __attribute_pure__ __nonnull ((1, 2, 3));
543
544extern int strncasecmp_l (const char *__s1, const char *__s2,
545   size_t __n, __locale_t __loc)
546     __THROW __attribute_pure__ __nonnull ((1, 2, 4));
547#endif
548
549#ifdef __USE_MISC
550/* Return the next DELIM-delimited token from *STRINGP,
551   terminating it with a '\0', and update *STRINGP to point past it.  */
552extern char *strsep (char **__restrict __stringp,
553      const char *__restrict __delim)
554     __THROW __nonnull ((1, 2));
555#endif
556
557#ifdef __USE_XOPEN2K8
558/* Return a string describing the meaning of the signal number in SIG.  */
559extern char *strsignal (int __sig) __THROW;
560
561/* Copy SRC to DEST, returning the address of the terminating '\0' in DEST.  */
562extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
563     __THROW __nonnull ((1, 2));
564extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
565     __THROW __nonnull ((1, 2));
566
567/* Copy no more than N characters of SRC to DEST, returning the address of
568   the last character written into DEST.  */
569extern char *__stpncpy (char *__restrict __dest,
570 const char *__restrict __src, size_t __n)
571     __THROW __nonnull ((1, 2));
572extern char *stpncpy (char *__restrict __dest,
573       const char *__restrict __src, size_t __n)
574     __THROW __nonnull ((1, 2));
575#endif
576
577#ifdef __USE_GNU
578/* Compare S1 and S2 as strings holding name & indices/version numbers.  */
579extern int strverscmp (const char *__s1, const char *__s2)
580     __THROW __attribute_pure__ __nonnull ((1, 2));
581
582/* Sautee STRING briskly.  */
583extern char *strfry (char *__string) __THROW __nonnull ((1));
584
585/* Frobnicate N bytes of S.  */
586extern void *memfrob (void *__s, size_t __n) __THROW __nonnull ((1));
587
588# ifndef basename
589/* Return the file name within directory of FILENAME.  We don't
590   declare the function if the `basename' macro is available (defined
591   in <libgen.h>) which makes the XPG version of this function
592   available.  */
593#  ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
594extern "C++" char *basename (char *__filename)
595     __THROW __asm ("basename") __nonnull ((1));
596extern "C++" const char *basename (const char *__filename)
597     __THROW __asm ("basename") __nonnull ((1));
598#  else
599extern char *basename (const char *__filename) __THROW __nonnull ((1));
600#  endif
601# endif
602#endif
603
604
605#if defined __GNUC__ && __GNUC__ >= 2
606# if defined __OPTIMIZE__ && !defined __OPTIMIZE_SIZE__ \
607     && !defined __NO_INLINE__ && !defined __cplusplus
608/* When using GNU CC we provide some optimized versions of selected
609   functions from this header.  There are two kinds of optimizations:
610
611   - machine-dependent optimizations, most probably using inline
612     assembler code; these might be quite expensive since the code
613     size can increase significantly.
614     These optimizations are not used unless the symbol
615 __USE_STRING_INLINES
616     is defined before including this header.
617
618   - machine-independent optimizations which do not increase the
619     code size significantly and which optimize mainly situations
620     where one or more arguments are compile-time constants.
621     These optimizations are used always when the compiler is
622     taught to optimize.
623
624   One can inhibit all optimizations by defining __NO_STRING_INLINES.  */
625
626/* Get the machine-dependent optimizations (if any).  */
627#  include <bits/string.h>
628
629/* These are generic optimizations which do not add too much inline code.  */
630#  include <bits/string2.h>
631# endif
632
633# if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function
634/* Functions with security checks.  */
635#  include <bits/string3.h>
636# endif
637#endif
638
639#if defined __USE_GNU && defined __OPTIMIZE__ \
640    && defined __extern_always_inline && __GNUC_PREREQ (3,2)
641# if !defined _FORCE_INLINES && !defined _HAVE_STRING_ARCH_mempcpy
642
643#undef mempcpy
644#undef __mempcpy
645#define mempcpy(dest, src, n) __mempcpy_inline (dest, src, n)
646#define __mempcpy(dest, src, n) __mempcpy_inline (dest, src, n)
647
648__extern_always_inline void *
649__mempcpy_inline (void *__restrict __dest,
650   const void *__restrict __src, size_t __n)
651{
652  return (char *) memcpy (__dest, __src, __n) + __n;
653}
654
655# endif
656#endif
657
658__END_DECLS
659
660#endif /* string.h  */
661
CodeThinker, Enjoy your reading code