1/* Copyright (C) 1991-2015 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__END_DECLS
640
641#endif /* string.h */
642