LCOV - code coverage report
Current view: top level - usr/include - string.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 1 0.0 %
Date: 2015-11-05 17:06:03 Functions: 0 1 0.0 %

          Line data    Source code
       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.  */
      46             : extern 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.  */
      50             : extern 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
      58             : extern 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.  */
      66             : extern void *memset (void *__s, int __c, size_t __n) __THROW __nonnull ((1));
      67             : 
      68             : /* Compare N bytes of S1 and S2.  */
      69             : extern 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
      74             : extern "C++"
      75             : {
      76             : extern void *memchr (void *__s, int __c, size_t __n)
      77             :       __THROW __asm ("memchr") __attribute_pure__ __nonnull ((1));
      78             : extern 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 *
      83             : memchr (void *__s, int __c, size_t __n) __THROW
      84             : {
      85             :   return __builtin_memchr (__s, __c, __n);
      86             : }
      87             : 
      88             : __extern_always_inline const void *
      89             : memchr (const void *__s, int __c, size_t __n) __THROW
      90             : {
      91             :   return __builtin_memchr (__s, __c, __n);
      92             : }
      93             : # endif
      94             : }
      95             : #else
      96             : extern 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
     105             : extern "C++" void *rawmemchr (void *__s, int __c)
     106             :      __THROW __asm ("rawmemchr") __attribute_pure__ __nonnull ((1));
     107             : extern "C++" const void *rawmemchr (const void *__s, int __c)
     108             :      __THROW __asm ("rawmemchr") __attribute_pure__ __nonnull ((1));
     109             : # else
     110             : extern 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
     116             : extern "C++" void *memrchr (void *__s, int __c, size_t __n)
     117             :       __THROW __asm ("memrchr") __attribute_pure__ __nonnull ((1));
     118             : extern "C++" const void *memrchr (const void *__s, int __c, size_t __n)
     119             :       __THROW __asm ("memrchr") __attribute_pure__ __nonnull ((1));
     120             : # else
     121             : extern 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.  */
     129             : extern 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.  */
     132             : extern char *strncpy (char *__restrict __dest,
     133             :                       const char *__restrict __src, size_t __n)
     134             :      __THROW __nonnull ((1, 2));
     135             : 
     136             : /* Append SRC onto DEST.  */
     137             : extern 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.  */
     140             : extern char *strncat (char *__restrict __dest, const char *__restrict __src,
     141             :                       size_t __n) __THROW __nonnull ((1, 2));
     142             : 
     143             : /* Compare S1 and S2.  */
     144             : extern int strcmp (const char *__s1, const char *__s2)
     145             :      __THROW __attribute_pure__ __nonnull ((1, 2));
     146             : /* Compare N characters of S1 and S2.  */
     147             : extern 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.  */
     151             : extern 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.  */
     154             : extern 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.  */
     166             : extern 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.  */
     169             : extern 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.  */
     176             : extern 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
     184             : extern 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
     214             : extern "C++"
     215             : {
     216             : extern char *strchr (char *__s, int __c)
     217             :      __THROW __asm ("strchr") __attribute_pure__ __nonnull ((1));
     218             : extern 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 *
     223             : strchr (char *__s, int __c) __THROW
     224             : {
     225             :   return __builtin_strchr (__s, __c);
     226             : }
     227             : 
     228             : __extern_always_inline const char *
     229             : strchr (const char *__s, int __c) __THROW
     230             : {
     231             :   return __builtin_strchr (__s, __c);
     232             : }
     233             : # endif
     234             : }
     235             : #else
     236             : extern 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
     241             : extern "C++"
     242             : {
     243             : extern char *strrchr (char *__s, int __c)
     244             :      __THROW __asm ("strrchr") __attribute_pure__ __nonnull ((1));
     245             : extern 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 *
     250             : strrchr (char *__s, int __c) __THROW
     251             : {
     252             :   return __builtin_strrchr (__s, __c);
     253             : }
     254             : 
     255             : __extern_always_inline const char *
     256             : strrchr (const char *__s, int __c) __THROW
     257             : {
     258             :   return __builtin_strrchr (__s, __c);
     259             : }
     260             : # endif
     261             : }
     262             : #else
     263             : extern 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
     272             : extern "C++" char *strchrnul (char *__s, int __c)
     273             :      __THROW __asm ("strchrnul") __attribute_pure__ __nonnull ((1));
     274             : extern "C++" const char *strchrnul (const char *__s, int __c)
     275             :      __THROW __asm ("strchrnul") __attribute_pure__ __nonnull ((1));
     276             : # else
     277             : extern 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.  */
     285             : extern 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.  */
     289             : extern 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
     293             : extern "C++"
     294             : {
     295             : extern char *strpbrk (char *__s, const char *__accept)
     296             :      __THROW __asm ("strpbrk") __attribute_pure__ __nonnull ((1, 2));
     297             : extern 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 *
     302             : strpbrk (char *__s, const char *__accept) __THROW
     303             : {
     304             :   return __builtin_strpbrk (__s, __accept);
     305             : }
     306             : 
     307             : __extern_always_inline const char *
     308             : strpbrk (const char *__s, const char *__accept) __THROW
     309             : {
     310             :   return __builtin_strpbrk (__s, __accept);
     311             : }
     312             : # endif
     313             : }
     314             : #else
     315             : extern 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
     320             : extern "C++"
     321             : {
     322             : extern char *strstr (char *__haystack, const char *__needle)
     323             :      __THROW __asm ("strstr") __attribute_pure__ __nonnull ((1, 2));
     324             : extern 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 *
     329             : strstr (char *__haystack, const char *__needle) __THROW
     330             : {
     331             :   return __builtin_strstr (__haystack, __needle);
     332             : }
     333             : 
     334             : __extern_always_inline const char *
     335             : strstr (const char *__haystack, const char *__needle) __THROW
     336             : {
     337             :   return __builtin_strstr (__haystack, __needle);
     338             : }
     339             : # endif
     340             : }
     341             : #else
     342             : extern 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.  */
     348             : extern 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.  */
     354             : extern 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
     359             : extern 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
     367             : extern "C++" char *strcasestr (char *__haystack, const char *__needle)
     368             :      __THROW __asm ("strcasestr") __attribute_pure__ __nonnull ((1, 2));
     369             : extern "C++" const char *strcasestr (const char *__haystack,
     370             :                                      const char *__needle)
     371             :      __THROW __asm ("strcasestr") __attribute_pure__ __nonnull ((1, 2));
     372             : # else
     373             : extern 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.  */
     382             : extern 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.  */
     388             : extern void *__mempcpy (void *__restrict __dest,
     389             :                         const void *__restrict __src, size_t __n)
     390             :      __THROW __nonnull ((1, 2));
     391             : extern 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.  */
     399             : extern 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.  */
     406             : extern 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.  */
     413             : extern 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
     427             : extern int __REDIRECT_NTH (strerror_r,
     428             :                            (int __errnum, char *__buf, size_t __buflen),
     429             :                            __xpg_strerror_r) __nonnull ((2));
     430             : #  else
     431             : extern 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.  */
     438             : extern 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.  */
     445             : extern 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.  */
     451             : extern 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).  */
     455             : extern void bcopy (const void *__src, void *__dest, size_t __n)
     456             :      __THROW __nonnull ((1, 2));
     457             : 
     458             : /* Set N bytes of S to 0.  */
     459             : extern void bzero (void *__s, size_t __n) __THROW __nonnull ((1));
     460             : 
     461             : /* Compare N bytes of S1 and S2 (same as memcmp).  */
     462             : extern 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
     467             : extern "C++"
     468             : {
     469             : extern char *index (char *__s, int __c)
     470             :      __THROW __asm ("index") __attribute_pure__ __nonnull ((1));
     471             : extern 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 *
     476             : index (char *__s, int __c) __THROW
     477             : {
     478             :   return __builtin_index (__s, __c);
     479             : }
     480             : 
     481             : __extern_always_inline const char *
     482             : index (const char *__s, int __c) __THROW
     483             : {
     484             :   return __builtin_index (__s, __c);
     485             : }
     486             : #  endif
     487             : }
     488             : # else
     489             : extern 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
     495             : extern "C++"
     496             : {
     497             : extern char *rindex (char *__s, int __c)
     498             :      __THROW __asm ("rindex") __attribute_pure__ __nonnull ((1));
     499             : extern 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 *
     504             : rindex (char *__s, int __c) __THROW
     505             : {
     506             :   return __builtin_rindex (__s, __c);
     507             : }
     508             : 
     509             : __extern_always_inline const char *
     510             : rindex (const char *__s, int __c) __THROW
     511             : {
     512             :   return __builtin_rindex (__s, __c);
     513             : }
     514             : #endif
     515             : }
     516             : # else
     517             : extern 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.  */
     523             : extern 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
     528             : extern 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.  */
     534             : extern 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.  */
     538             : extern 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.  */
     545             : extern int strcasecmp_l (const char *__s1, const char *__s2,
     546             :                          __locale_t __loc)
     547             :      __THROW __attribute_pure__ __nonnull ((1, 2, 3));
     548             : 
     549             : extern 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.  */
     557             : extern 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.  */
     564             : extern char *strsignal (int __sig) __THROW;
     565             : 
     566             : /* Copy SRC to DEST, returning the address of the terminating '\0' in DEST.  */
     567             : extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
     568             :      __THROW __nonnull ((1, 2));
     569           0 : extern 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.  */
     574             : extern char *__stpncpy (char *__restrict __dest,
     575             :                         const char *__restrict __src, size_t __n)
     576             :      __THROW __nonnull ((1, 2));
     577             : extern 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.  */
     584             : extern int strverscmp (const char *__s1, const char *__s2)
     585             :      __THROW __attribute_pure__ __nonnull ((1, 2));
     586             : 
     587             : /* Sautee STRING briskly.  */
     588             : extern char *strfry (char *__string) __THROW __nonnull ((1));
     589             : 
     590             : /* Frobnicate N bytes of S.  */
     591             : extern 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
     599             : extern "C++" char *basename (char *__filename)
     600             :      __THROW __asm ("basename") __nonnull ((1));
     601             : extern "C++" const char *basename (const char *__filename)
     602             :      __THROW __asm ("basename") __nonnull ((1));
     603             : #  else
     604             : extern 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  */

Generated by: LCOV version 1.11