1/* Copyright (C) 1991-2026 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 <https://www.gnu.org/licenses/>. */
17
18/*
19 * ISO C99 Standard: 7.21 String handling <string.h>
20 */
21
22#ifndef _STRING_H
23#define _STRING_H 1
24
25#define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION
26#include <bits/libc-header-start.h>
27
28__BEGIN_DECLS
29
30#if __GLIBC_USE (ISOC23)
31# define __STDC_VERSION_STRING_H__ 202311L
32#endif
33
34/* Get size_t and NULL from <stddef.h>. */
35#define __need_size_t
36#define __need_NULL
37#include <stddef.h>
38
39/* Tell the caller that we provide correct C++ prototypes. */
40#if defined __cplusplus && (__GNUC_PREREQ (4, 4) \
41 || __glibc_clang_prereq (3, 5))
42# define __CORRECT_ISO_CPP_STRING_H_PROTO
43#endif
44
45
46/* Copy N bytes of SRC to DEST. */
47extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
48 size_t __n) __THROW __nonnull ((1, 2));
49/* Copy N bytes of SRC to DEST, guaranteeing
50 correct behavior for overlapping strings. */
51extern void *memmove (void *__dest, const void *__src, size_t __n)
52 __THROW __nonnull ((1, 2));
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_MISC || defined __USE_XOPEN || __GLIBC_USE (ISOC23)
58extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
59 int __c, size_t __n)
60 __THROW __nonnull ((1, 2)) __attr_access ((__write_only__, 1, 4));
61#endif /* Misc || X/Open. */
62
63
64/* Set N bytes of S to C. */
65extern void *memset (void *__s, int __c, size_t __n) __THROW __nonnull ((1));
66
67#if defined __USE_MISC || __GLIBC_USE (ISOC23)
68/* Like memset, but the compiler will not delete a call to this
69 function, even if S is dead after the call. */
70extern void *memset_explicit (void *__s, int __c, size_t __n)
71 __THROW __nonnull ((1)) __fortified_attr_access (__write_only__, 1, 3);
72#endif
73
74/* Compare N bytes of S1 and S2. */
75extern int memcmp (const void *__s1, const void *__s2, size_t __n)
76 __THROW __attribute_pure__ __nonnull ((1, 2));
77
78/* Compare N bytes of S1 and S2. Return zero if S1 and S2 are equal.
79 Return some non-zero value otherwise.
80
81 Essentially __memcmpeq has the exact same semantics as memcmp
82 except the return value is less constrained. memcmp is always a
83 correct implementation of __memcmpeq. As well !!memcmp, -memcmp,
84 or bcmp are correct implementations.
85
86 __memcmpeq is meant to be used by compilers when memcmp return is
87 only used for its boolean value.
88
89 __memcmpeq is declared only for use by compilers. Programs should
90 continue to use memcmp. */
91extern int __memcmpeq (const void *__s1, const void *__s2, size_t __n)
92 __THROW __attribute_pure__ __nonnull ((1, 2));
93
94/* Search N bytes of S for C. */
95#ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
96extern "C++"
97{
98extern void *memchr (void *__s, int __c, size_t __n)
99 __THROW __asm ("memchr") __attribute_pure__ __nonnull ((1));
100extern const void *memchr (const void *__s, int __c, size_t __n)
101 __THROW __asm ("memchr") __attribute_pure__ __nonnull ((1));
102
103# ifdef __OPTIMIZE__
104__extern_always_inline void *
105memchr (void *__s, int __c, size_t __n) __THROW
106{
107 return __builtin_memchr (__s, __c, __n);
108}
109
110__extern_always_inline const void *
111memchr (const void *__s, int __c, size_t __n) __THROW
112{
113 return __builtin_memchr (__s, __c, __n);
114}
115# endif
116}
117#else
118extern void *memchr (const void *__s, int __c, size_t __n)
119 __THROW __attribute_pure__ __nonnull ((1));
120# if __GLIBC_USE (ISOC23) && defined __glibc_const_generic && !defined _LIBC
121# define memchr(S, C, N) \
122 __glibc_const_generic (S, const void *, memchr (S, C, N))
123# endif
124#endif
125
126#ifdef __USE_GNU
127/* Search in S for C. This is similar to `memchr' but there is no
128 length limit. */
129# ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
130extern "C++" void *rawmemchr (void *__s, int __c)
131 __THROW __asm ("rawmemchr") __attribute_pure__ __nonnull ((1));
132extern "C++" const void *rawmemchr (const void *__s, int __c)
133 __THROW __asm ("rawmemchr") __attribute_pure__ __nonnull ((1));
134# else
135extern void *rawmemchr (const void *__s, int __c)
136 __THROW __attribute_pure__ __nonnull ((1));
137# endif
138
139/* Search N bytes of S for the final occurrence of C. */
140# ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
141extern "C++" void *memrchr (void *__s, int __c, size_t __n)
142 __THROW __asm ("memrchr") __attribute_pure__ __nonnull ((1))
143 __attr_access ((__read_only__, 1, 3));
144extern "C++" const void *memrchr (const void *__s, int __c, size_t __n)
145 __THROW __asm ("memrchr") __attribute_pure__ __nonnull ((1))
146 __attr_access ((__read_only__, 1, 3));
147# else
148extern void *memrchr (const void *__s, int __c, size_t __n)
149 __THROW __attribute_pure__ __nonnull ((1))
150 __attr_access ((__read_only__, 1, 3));
151# endif
152#endif
153
154
155/* Copy SRC to DEST. */
156extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
157 __THROW __nonnull ((1, 2));
158/* Copy no more than N characters of SRC to DEST. */
159extern char *strncpy (char *__restrict __dest,
160 const char *__restrict __src, size_t __n)
161 __THROW __nonnull ((1, 2));
162
163/* Append SRC onto DEST. */
164extern char *strcat (char *__restrict __dest, const char *__restrict __src)
165 __THROW __nonnull ((1, 2));
166/* Append no more than N characters from SRC onto DEST. */
167extern char *strncat (char *__restrict __dest, const char *__restrict __src,
168 size_t __n) __THROW __nonnull ((1, 2));
169
170/* Compare S1 and S2. */
171extern int strcmp (const char *__s1, const char *__s2)
172 __THROW __attribute_pure__ __nonnull ((1, 2));
173/* Compare N characters of S1 and S2. */
174extern int strncmp (const char *__s1, const char *__s2, size_t __n)
175 __THROW __attribute_pure__ __nonnull ((1, 2));
176
177/* Compare the collated forms of S1 and S2. */
178extern int strcoll (const char *__s1, const char *__s2)
179 __THROW __attribute_pure__ __nonnull ((1, 2));
180/* Put a transformation of SRC into no more than N bytes of DEST. */
181extern size_t strxfrm (char *__restrict __dest,
182 const char *__restrict __src, size_t __n)
183 __THROW __nonnull ((2)) __attr_access ((__write_only__, 1, 3));
184
185#ifdef __USE_XOPEN2K8
186/* POSIX.1-2008 extended locale interface (see locale.h). */
187# include <bits/types/locale_t.h>
188
189/* Compare the collated forms of S1 and S2, using sorting rules from L. */
190extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l)
191 __THROW __attribute_pure__ __nonnull ((1, 2, 3));
192/* Put a transformation of SRC into no more than N bytes of DEST,
193 using sorting rules from L. */
194extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
195 locale_t __l) __THROW __nonnull ((2, 4))
196 __attr_access ((__write_only__, 1, 3));
197#endif
198
199#if (defined __USE_XOPEN_EXTENDED || defined __USE_XOPEN2K8 \
200 || __GLIBC_USE (LIB_EXT2) || __GLIBC_USE (ISOC23))
201/* Duplicate S, returning an identical malloc'd string. */
202extern char *strdup (const char *__s)
203 __THROW __attribute_malloc__ __nonnull ((1));
204#endif
205
206/* Return a malloc'd copy of at most N bytes of STRING. The
207 resultant string is terminated even if no null terminator
208 appears before STRING[N]. */
209#if defined __USE_XOPEN2K8 || __GLIBC_USE (LIB_EXT2) || __GLIBC_USE (ISOC23)
210extern char *strndup (const char *__string, size_t __n)
211 __THROW __attribute_malloc__ __nonnull ((1));
212#endif
213
214#if defined __USE_GNU && defined __GNUC__
215/* Duplicate S, returning an identical alloca'd string. */
216# define strdupa(s) \
217 (__extension__ \
218 ({ \
219 const char *__old = (s); \
220 size_t __len = strlen (__old) + 1; \
221 char *__new = (char *) __builtin_alloca (__len); \
222 (char *) memcpy (__new, __old, __len); \
223 }))
224
225/* Return an alloca'd copy of at most N bytes of string. */
226# define strndupa(s, n) \
227 (__extension__ \
228 ({ \
229 const char *__old = (s); \
230 size_t __len = strnlen (__old, (n)); \
231 char *__new = (char *) __builtin_alloca (__len + 1); \
232 __new[__len] = '\0'; \
233 (char *) memcpy (__new, __old, __len); \
234 }))
235#endif
236
237/* Find the first occurrence of C in S. */
238#ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
239extern "C++"
240{
241extern char *strchr (char *__s, int __c)
242 __THROW __asm ("strchr") __attribute_pure__ __nonnull ((1));
243extern const char *strchr (const char *__s, int __c)
244 __THROW __asm ("strchr") __attribute_pure__ __nonnull ((1));
245
246# ifdef __OPTIMIZE__
247__extern_always_inline char *
248strchr (char *__s, int __c) __THROW
249{
250 return __builtin_strchr (__s, __c);
251}
252
253__extern_always_inline const char *
254strchr (const char *__s, int __c) __THROW
255{
256 return __builtin_strchr (__s, __c);
257}
258# endif
259}
260#else
261extern char *strchr (const char *__s, int __c)
262 __THROW __attribute_pure__ __nonnull ((1));
263# if __GLIBC_USE (ISOC23) && defined __glibc_const_generic && !defined _LIBC
264# define strchr(S, C) \
265 __glibc_const_generic (S, const char *, strchr (S, C))
266# endif
267#endif
268/* Find the last occurrence of C in S. */
269#ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
270extern "C++"
271{
272extern char *strrchr (char *__s, int __c)
273 __THROW __asm ("strrchr") __attribute_pure__ __nonnull ((1));
274extern const char *strrchr (const char *__s, int __c)
275 __THROW __asm ("strrchr") __attribute_pure__ __nonnull ((1));
276
277# ifdef __OPTIMIZE__
278__extern_always_inline char *
279strrchr (char *__s, int __c) __THROW
280{
281 return __builtin_strrchr (__s, __c);
282}
283
284__extern_always_inline const char *
285strrchr (const char *__s, int __c) __THROW
286{
287 return __builtin_strrchr (__s, __c);
288}
289# endif
290}
291#else
292extern char *strrchr (const char *__s, int __c)
293 __THROW __attribute_pure__ __nonnull ((1));
294# if __GLIBC_USE (ISOC23) && defined __glibc_const_generic && !defined _LIBC
295# define strrchr(S, C) \
296 __glibc_const_generic (S, const char *, strrchr (S, C))
297# endif
298#endif
299
300#ifdef __USE_MISC
301/* This function is similar to `strchr'. But it returns a pointer to
302 the closing NUL byte in case C is not found in S. */
303# ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
304extern "C++" char *strchrnul (char *__s, int __c)
305 __THROW __asm ("strchrnul") __attribute_pure__ __nonnull ((1));
306extern "C++" const char *strchrnul (const char *__s, int __c)
307 __THROW __asm ("strchrnul") __attribute_pure__ __nonnull ((1));
308# else
309extern char *strchrnul (const char *__s, int __c)
310 __THROW __attribute_pure__ __nonnull ((1));
311# endif
312#endif
313
314/* Return the length of the initial segment of S which
315 consists entirely of characters not in REJECT. */
316extern size_t strcspn (const char *__s, const char *__reject)
317 __THROW __attribute_pure__ __nonnull ((1, 2));
318/* Return the length of the initial segment of S which
319 consists entirely of characters in ACCEPT. */
320extern size_t strspn (const char *__s, const char *__accept)
321 __THROW __attribute_pure__ __nonnull ((1, 2));
322/* Find the first occurrence in S of any character in ACCEPT. */
323#ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
324extern "C++"
325{
326extern char *strpbrk (char *__s, const char *__accept)
327 __THROW __asm ("strpbrk") __attribute_pure__ __nonnull ((1, 2));
328extern const char *strpbrk (const char *__s, const char *__accept)
329 __THROW __asm ("strpbrk") __attribute_pure__ __nonnull ((1, 2));
330
331# ifdef __OPTIMIZE__
332__extern_always_inline char *
333strpbrk (char *__s, const char *__accept) __THROW
334{
335 return __builtin_strpbrk (__s, __accept);
336}
337
338__extern_always_inline const char *
339strpbrk (const char *__s, const char *__accept) __THROW
340{
341 return __builtin_strpbrk (__s, __accept);
342}
343# endif
344}
345#else
346extern char *strpbrk (const char *__s, const char *__accept)
347 __THROW __attribute_pure__ __nonnull ((1, 2));
348# if __GLIBC_USE (ISOC23) && defined __glibc_const_generic && !defined _LIBC
349# define strpbrk(S, ACCEPT) \
350 __glibc_const_generic (S, const char *, strpbrk (S, ACCEPT))
351# endif
352#endif
353/* Find the first occurrence of NEEDLE in HAYSTACK. */
354#ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
355extern "C++"
356{
357extern char *strstr (char *__haystack, const char *__needle)
358 __THROW __asm ("strstr") __attribute_pure__ __nonnull ((1, 2));
359extern const char *strstr (const char *__haystack, const char *__needle)
360 __THROW __asm ("strstr") __attribute_pure__ __nonnull ((1, 2));
361
362# ifdef __OPTIMIZE__
363__extern_always_inline char *
364strstr (char *__haystack, const char *__needle) __THROW
365{
366 return __builtin_strstr (__haystack, __needle);
367}
368
369__extern_always_inline const char *
370strstr (const char *__haystack, const char *__needle) __THROW
371{
372 return __builtin_strstr (__haystack, __needle);
373}
374# endif
375}
376#else
377extern char *strstr (const char *__haystack, const char *__needle)
378 __THROW __attribute_pure__ __nonnull ((1, 2));
379# if __GLIBC_USE (ISOC23) && defined __glibc_const_generic && !defined _LIBC
380# define strstr(HAYSTACK, NEEDLE) \
381 __glibc_const_generic (HAYSTACK, const char *, \
382 strstr (HAYSTACK, NEEDLE))
383# endif
384#endif
385
386
387/* Divide S into tokens separated by characters in DELIM. */
388extern char *strtok (char *__restrict __s, const char *__restrict __delim)
389 __THROW __nonnull ((2));
390
391/* Divide S into tokens separated by characters in DELIM. Information
392 passed between calls are stored in SAVE_PTR. */
393extern char *__strtok_r (char *__restrict __s,
394 const char *__restrict __delim,
395 char **__restrict __save_ptr)
396 __THROW __nonnull ((2, 3));
397#ifdef __USE_POSIX
398extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
399 char **__restrict __save_ptr)
400 __THROW __nonnull ((2, 3));
401#endif
402
403#ifdef __USE_MISC
404/* Similar to `strstr' but this function ignores the case of both strings. */
405# ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
406extern "C++" char *strcasestr (char *__haystack, const char *__needle)
407 __THROW __asm ("strcasestr") __attribute_pure__ __nonnull ((1, 2));
408extern "C++" const char *strcasestr (const char *__haystack,
409 const char *__needle)
410 __THROW __asm ("strcasestr") __attribute_pure__ __nonnull ((1, 2));
411# else
412extern char *strcasestr (const char *__haystack, const char *__needle)
413 __THROW __attribute_pure__ __nonnull ((1, 2));
414# endif
415#endif
416
417#ifdef __USE_MISC
418/* Find the first occurrence of NEEDLE in HAYSTACK.
419 NEEDLE is NEEDLELEN bytes long;
420 HAYSTACK is HAYSTACKLEN bytes long. */
421extern void *memmem (const void *__haystack, size_t __haystacklen,
422 const void *__needle, size_t __needlelen)
423 __THROW __attribute_pure__ __nonnull ((1, 3))
424 __attr_access ((__read_only__, 1, 2))
425 __attr_access ((__read_only__, 3, 4));
426
427/* Copy N bytes of SRC to DEST, return pointer to bytes after the
428 last written byte. */
429extern void *__mempcpy (void *__restrict __dest,
430 const void *__restrict __src, size_t __n)
431 __THROW __nonnull ((1, 2));
432extern void *mempcpy (void *__restrict __dest,
433 const void *__restrict __src, size_t __n)
434 __THROW __nonnull ((1, 2));
435#endif
436
437
438/* Return the length of S. */
439extern size_t strlen (const char *__s)
440 __THROW __attribute_pure__ __nonnull ((1));
441
442#ifdef __USE_XOPEN2K8
443/* Find the length of STRING, but scan at most MAXLEN characters.
444 If no '\0' terminator is found in that many characters, return MAXLEN. */
445extern size_t strnlen (const char *__string, size_t __maxlen)
446 __THROW __attribute_pure__ __nonnull ((1));
447#endif
448
449
450/* Return a string describing the meaning of the `errno' code in ERRNUM. */
451extern char *strerror (int __errnum) __THROW;
452#ifdef __USE_XOPEN2K
453/* Reentrant version of `strerror'.
454 There are 2 flavors of `strerror_r', GNU which returns the string
455 and may or may not use the supplied temporary buffer and POSIX one
456 which fills the string into the buffer.
457 To use the POSIX version, -D_XOPEN_SOURCE=600 or -D_POSIX_C_SOURCE=200112L
458 without -D_GNU_SOURCE is needed, otherwise the GNU version is
459 preferred. */
460# if defined __USE_XOPEN2K && !defined __USE_GNU
461/* Fill BUF with a string describing the meaning of the `errno' code in
462 ERRNUM. */
463# ifdef __REDIRECT_NTH
464extern int __REDIRECT_NTH (strerror_r,
465 (int __errnum, char *__buf, size_t __buflen),
466 __xpg_strerror_r) __nonnull ((2))
467 __attr_access ((__write_only__, 2, 3));
468# else
469extern int __xpg_strerror_r (int __errnum, char *__buf, size_t __buflen)
470 __THROW __nonnull ((2)) __attr_access ((__write_only__, 2, 3));
471# define strerror_r __xpg_strerror_r
472# endif
473# else
474/* If a temporary buffer is required, at most BUFLEN bytes of BUF will be
475 used. */
476extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
477 __THROW __nonnull ((2)) __wur __attr_access ((__write_only__, 2, 3));
478# endif
479
480# ifdef __USE_GNU
481/* Return a string describing the meaning of tthe error in ERR. */
482extern const char *strerrordesc_np (int __err) __THROW;
483/* Return a string with the error name in ERR. */
484extern const char *strerrorname_np (int __err) __THROW;
485# endif
486#endif
487
488#ifdef __USE_XOPEN2K8
489/* Translate error number to string according to the locale L. */
490extern char *strerror_l (int __errnum, locale_t __l) __THROW;
491#endif
492
493#ifdef __USE_MISC
494# include <strings.h>
495
496/* Set N bytes of S to 0. The compiler will not delete a call to this
497 function, even if S is dead after the call. */
498extern void explicit_bzero (void *__s, size_t __n) __THROW __nonnull ((1))
499 __fortified_attr_access (__write_only__, 1, 2);
500
501/* Return the next DELIM-delimited token from *STRINGP,
502 terminating it with a '\0', and update *STRINGP to point past it. */
503extern char *strsep (char **__restrict __stringp,
504 const char *__restrict __delim)
505 __THROW __nonnull ((1, 2));
506#endif
507
508#ifdef __USE_XOPEN2K8
509/* Return a string describing the meaning of the signal number in SIG. */
510extern char *strsignal (int __sig) __THROW;
511
512# ifdef __USE_GNU
513/* Return an abbreviation string for the signal number SIG. */
514extern const char *sigabbrev_np (int __sig) __THROW;
515/* Return a string describing the meaning of the signal number in SIG,
516 the result is not translated. */
517extern const char *sigdescr_np (int __sig) __THROW;
518# endif
519
520/* Copy SRC to DEST, returning the address of the terminating '\0' in DEST. */
521extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
522 __THROW __nonnull ((1, 2));
523extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
524 __THROW __nonnull ((1, 2));
525
526/* Copy no more than N characters of SRC to DEST, returning the address of
527 the last character written into DEST. */
528extern char *__stpncpy (char *__restrict __dest,
529 const char *__restrict __src, size_t __n)
530 __THROW __nonnull ((1, 2));
531extern char *stpncpy (char *__restrict __dest,
532 const char *__restrict __src, size_t __n)
533 __THROW __nonnull ((1, 2));
534#endif
535
536#ifdef __USE_MISC
537/* Copy at most N - 1 characters from SRC to DEST. */
538extern size_t strlcpy (char *__restrict __dest,
539 const char *__restrict __src, size_t __n)
540 __THROW __nonnull ((1, 2)) __attr_access ((__write_only__, 1, 3));
541
542/* Append SRC to DEST, possibly with truncation to keep the total size
543 below N. */
544extern size_t strlcat (char *__restrict __dest,
545 const char *__restrict __src, size_t __n)
546 __THROW __nonnull ((1, 2)) __attr_access ((__read_write__, 1, 3));
547#endif
548
549#ifdef __USE_GNU
550/* Compare S1 and S2 as strings holding name & indices/version numbers. */
551extern int strverscmp (const char *__s1, const char *__s2)
552 __THROW __attribute_pure__ __nonnull ((1, 2));
553
554/* Sautee STRING briskly. */
555extern char *strfry (char *__string) __THROW __nonnull ((1));
556
557/* Frobnicate N bytes of S. */
558extern void *memfrob (void *__s, size_t __n) __THROW __nonnull ((1))
559 __attr_access ((__read_write__, 1, 2));
560
561# ifndef basename
562/* Return the file name within directory of FILENAME. We don't
563 declare the function if the `basename' macro is available (defined
564 in <libgen.h>) which makes the XPG version of this function
565 available. */
566# ifdef __CORRECT_ISO_CPP_STRING_H_PROTO
567extern "C++" char *basename (char *__filename)
568 __THROW __asm ("basename") __nonnull ((1));
569extern "C++" const char *basename (const char *__filename)
570 __THROW __asm ("basename") __nonnull ((1));
571# else
572extern char *basename (const char *__filename) __THROW __nonnull ((1));
573# endif
574# endif
575#endif
576
577#if __GNUC_PREREQ (3,4)
578# if __USE_FORTIFY_LEVEL > 0 && defined __fortify_function
579/* Functions with security checks. */
580# include <bits/string_fortified.h>
581# endif
582#endif
583
584__END_DECLS
585
586#endif /* string.h */
587