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