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