string.h File Reference

#include <stddef.h>
#include <stdint.h>

Include dependency graph for string.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
int	memcmp (const void *s1, const void *s2, size_t n)
	Compares the first n characters of the two objects pointed to by s1 and s2. More...
void *	memset (void *dest, int c, size_t n)
	Copies the value c into each of the first n characters of the object pointed to by dest. More...
void *	memcpy (void *__restrict dest, const void *__restrict src, size_t n)
	Copies n characters from the object pointed to by src to the object pointed to by dest. More...
void *	memmove (void *dest, const void *src, size_t n)
	Copies n characters from the object pointed to by src to the object pointed to by dest. More...
void *	memchr (const void *s, int c, size_t n)
	Finds the first occurrence of c in the initial n characters of the object pointed to by s. More...
void *	memmem (const void *l, size_t l_len, const void *s, size_t s_len)
	Find substring s in memory area l. More...
size_t	strlen (const char *str)
	Returns the length of the given null-terminated byte string. More...
size_t	strnlen (const char *str, size_t maxlen)
	Returns the length of the given null-terminated byte string. More...
char *	strcpy (char *__restrict dst, const char *__restrict src)
	Copies the null-terminated byte string pointed to by src to the character array whose first element is pointed to by dest. More...
char *	strncpy (char *__restrict dst, const char *__restrict src, size_t maxlen)
	Copies at most maxlen characters of the character array pointed to by src to character array pointed to by dest. More...
char *	strstr (const char *string, const char *substring)
	Finds the first occurrence of the substring in the string. More...
char *	strnstr (const char *s, const char *find, size_t slen)
	Finds the first occurrence of find in the initial slen characters of the object pointed to by s. More...
int	strcmp (const char *s1, const char *s2)
	Compares two null-terminated byte strings lexicographically. More...
int	strncmp (const char *s1, const char *s2, size_t n)
	Compares at most n characters of two possibly null-terminated arrays. More...
char *	strdup (const char *str)
	Duplicate the passed in string str. More...
char *	strndup (const char *str, size_t n)
	Duplicate n bytes of the passed in string str. More...
char *	strchr (const char *s, int c)
	Finds the first occurrence of c in the null-terminated byte string pointed to by s. More...
char *	strrchr (const char *s, int c)
	Finds the last occurrence of c in the null-terminated byte string pointed to by s. More...
char *	strcat (char *__restrict dst, const char *__restrict src)
	Appends a copy of the null-terminated byte string pointed to by src to the end of the null-terminated byte string pointed to by dest. More...
char *	strncat (char *__restrict dst, const char *__restrict src, size_t maxlen)
	Appends at most maxlen characters from the character array pointed to by src, to the end of the null-terminated byte string pointed to by dest. More...
char *	strtok (char *s, const char *delim)
	Finds the next token in a null-terminated byte string pointed to by s. More...
size_t	strxfrm (char *__restrict, const char *__restrict, size_t)
size_t	strcspn (const char *, const char *)
size_t	strspn (const char *, const char *)
char *	strpbrk (const char *, const char *)
int	strcoll (const char *, const char *)
char *	strerror (int)
int	strerror_r (int, char *, size_t)

Function Documentation

memchr()

void* memchr	(	const void *	s,
		int	c,
		size_t	n
	)

Finds the first occurrence of c in the initial n characters of the object pointed to by s.

Finds the first occurrence of c (after conversion to unsigned char as if by (unsigned char)c ) in the initial n characters (each interpreted as unsigned char) of the object pointed to by s.

The behavior is undefined if access occurs beyond the end of the array (s) searched. The behavior is undefined if s is a null pointer.

Parameters

s	pointer to the object to be examined
c	character to search for
n	max number of characters to examine

Returns

a copy of dest

Definition at line 13 of file memchr.c.

{
    const unsigned char* s = src;
    c = (unsigned char)c;

#ifdef __GNUC__
    for(; ((uintptr_t)s & ALIGN) && n && *s != c; s++, n--)
    {
    }

    if(n && *s != c)
    {
        typedef size_t __attribute__((__may_alias__)) word;
        const word* w;
        size_t k = ONES * (size_t)c;

        for(w = (const void*)s; n >= SS && !HASZERO(*w ^ k); w++, n -= SS)
        {
        }

        s = (const void*)w;
    }
#endif

    for(; n && *s != c; s++, n--)
    {
    }

    return n ? (void*)(uintptr_t)s : 0;
}

References __attribute__(), ALIGN, HASZERO, ONES, and SS.

Referenced by memmem().

Here is the caller graph for this function:

memcmp()

int memcmp	(	const void *	s1,
		const void *	s2,
		size_t	n
	)

Compares the first n characters of the two objects pointed to by s1 and s2.

Compares the first n characters of the objects pointed to by s1 and s2. The comparison is done lexicographically.

The behavior is undefined if access occurs beyond the end of either object pointed to by s1 and s2. The behavior is undefined if either s1 or s2 is a null pointer.

Parameters

s1	pointers to the objects to compare
s2	pointers to the objects to compare
n	the number of bytes to examine

Returns

Negative value if s1 appears before s2 in lexicographical order. Zero if s1 and s2 compare equal, or if n is zero. Positive value if s1 appears after s2 in lexicographical order.

Referenced by memmem().

memcpy()

void* memcpy	(	void *__restrict	dest,
		const void *__restrict	src,
		size_t	n
	)

Copies n characters from the object pointed to by src to the object pointed to by dest.

Copies n characters from the object pointed to by src to the object pointed to by dest. Both objects are interpreted as arrays of unsigned char.

The behavior is undefined if access occurs beyond the end of the dest array. If the objects overlap (which is a violation of the restrict contract) (since C99), the behavior is undefined. The behavior is undefined if either dest or src is a null pointer.

Parameters

dest	pointer to the object to copy to
src	pointer to the object to copy from
n	number of bytes to copy

Returns

a copy of dest

Referenced by __attribute__(), realloc(), strcat(), strcpy(), strdup(), strerror_r(), strncat(), strncpy(), and strndup().

memmem()

void* memmem	(	const void *	l,
		size_t	l_len,
		const void *	s,
		size_t	s_len
	)

Find substring s in memory area l.

Finds the start of the first occurrence of the substring s of length s_len in the memory area l of length l_len.

The behavior is undefined if access occurs beyond the end of the array (s) searched. The behavior is undefined if s is a null pointer.

Parameters

l	pointer to the object to be examined
l_len	number of characters to examine
s	the substring to search for
s_len	number of characters to examine

Returns

a pointer to the beginning of the substring, or NULL if the substring is not found.

Definition at line 34 of file memmem.c.

{
    const register char *cur, *last;
    const char* cl = (const char*)l;
    const char* cs = (const char*)s;

    /* we need something to compare */
    if(l_len == 0 || s_len == 0)
    {
        return NULL;
    }

    /* "s" must be smaller or equal to "l" */
    if(l_len < s_len)
    {
        return NULL;
    }

    /* special case where s_len == 1 */
    if(s_len == 1)
    {
        return memchr(l, (int)*cs, l_len);
    }

    /* the last position where its possible to find "s" in "l" */
    last = cl + l_len - s_len;

    for(cur = cl; cur <= last; cur++)
    {
        if(cur[0] == cs[0] && memcmp(cur, cs, s_len) == 0)
        {
            return (void*)(uintptr_t)cur;
        }
    }

    return NULL;
}

References memchr(), memcmp(), and NULL.

memmove()

void* memmove	(	void *	dest,
		const void *	src,
		size_t	n
	)

Copies n characters from the object pointed to by src to the object pointed to by dest.

Copies n characters from the object pointed to by src to the object pointed to by dest. Both objects are interpreted as arrays of unsigned char.

The behavior is undefined if access occurs beyond the end of the dest array. The behavior is undefined if either dest or src is a null pointer.

Parameters

dest	pointer to the object to copy to
src	pointer to the object to copy from
n	number of bytes to copy

Returns

a copy of dest

memset()

void* memset	(	void *	dest,
		int	c,
		size_t	n
	)

Copies the value c into each of the first n characters of the object pointed to by dest.

Copies the value c (after conversion to unsigned char as if by (unsigned char)c ) into each of the first n characters of the object pointed to by dest.

The behavior is undefined if access occurs beyond the end of the dest array. The behavior is undefined if dest is a null pointer.

Parameters

dest	pointer to the object to fill
c	fill byte
n	number of bytes to fill

Returns

A copy of dest

Referenced by calloc(), CRTStartup(), strcspn(), and strncpy().

strcat()

char* strcat	(	char *__restrict	dst,
		const char *__restrict	src
	)

Appends a copy of the null-terminated byte string pointed to by src to the end of the null-terminated byte string pointed to by dest.

Appends a copy of the null-terminated byte string pointed to by src to the end of the null-terminated byte string pointed to by dest. The character src[0] replaces the null terminator at the end of dest. The resulting byte string is null-terminated.

The behavior is undefined if the destination array is not large enough for the contents of both src and dest and the terminating null character. The behavior is undefined if the strings overlap. The behavior is undefined if either dest or src is not a pointer to a null-terminated byte string.

Parameters

dst	pointer to the null-terminated byte string to append to
src	pointer to the null-terminated byte string to copy from

Returns

a copy of dest

Definition at line 26 of file strcat.c.

{
    const size_t dstlen = strlen(dst);
    const size_t srclen = strlen(src);
    //  The strcat() and strncat() functions append a copy of the null-
    //  terminated string src to the end of the null-terminated string dst,
    //  then add a terminating '\0'.  The string dst must have sufficient
    //  space to hold the result.
    memcpy(dst + dstlen, src, srclen + 1);
    //  The strcat() and strncat() functions return dst.
    return dst;
}

References memcpy(), and strlen().

strchr()

char* strchr	(	const char *	s,
		int	c
	)

Finds the first occurrence of c in the null-terminated byte string pointed to by s.

Finds the first occurrence of c (after conversion to char as if by (char)c ) in the null-terminated byte string pointed to by s (each character interpreted as unsigned char). The terminating null character is considered to be a part of the string and can be found when searching for '\0'.

The behavior is undefined if s is not a pointer to a null-terminated byte string.

Parameters

s	pointer to the null-terminated byte string to be analyzed
c	character to search for

Returns

a pointer to the found character in s, or null pointer if no such character is found.

Definition at line 7 of file strchr.c.

{
    char* r = __strchrnul(s, c);
    return *(unsigned char*)r == (unsigned char)c ? r : 0;
}

References __strchrnul().

strcmp()

int strcmp	(	const char *	s1,
		const char *	s2
	)

Compares two null-terminated byte strings lexicographically.

Compares two null-terminated byte strings lexicographically.

The behavior is undefined if s1 or s2 are not pointers to null-terminated byte strings.

Parameters

s1	pointers to the null-terminated byte strings to compare
s2	pointers to the null-terminated byte strings to compare

Returns

Negative value if s1 appears before s2 in lexicographical order. Zero if s1 and s2 compare equal, or if n is zero. Positive value if s1 appears after s2 in lexicographical order.

Definition at line 12 of file strcmp.c.

{
    int r = -1;

    if(s1 == s2)
    {
        // short circuit - same string
        return 0;
    }

    // I don't want to panic with a NULL ptr - we'll fall through and fail w/ -1
    if(s1 != NULL && s2 != NULL)
    {
        // iterate through strings until they don't match or s1 ends (null-term)
        for(; *s1 == *s2; ++s1, ++s2)
        {
            if(*s1 == 0)
            {
                r = 0;
                break;
            }
        }

        // handle case where we didn't break early - set return code.
        if(r != 0)
        {
            r = *(const char*)s1 - *(const char*)s2;
        }
    }

    return r;
}

References NULL.

Referenced by strcoll(), wctrans(), and wctype().

Here is the caller graph for this function:

strcoll()

int strcoll	(	const char *	,
		const char *
	)

Definition at line 3 of file strcoll.c.

{
    return strcmp(l, r);
}

References strcmp().

strcpy()

char* strcpy	(	char *__restrict	dst,
		const char *__restrict	src
	)

Copies the null-terminated byte string pointed to by src to the character array whose first element is pointed to by dest.

Copies the null-terminated byte string pointed to by src, including the null terminator, to the character array whose first element is pointed to by dest. It may clobber the rest of the destination array with unspecified values and that the following errors are detected at runtime and call the currently installed constraint handler function: The behavior is undefined if the dest array is not large enough. The behavior is undefined if the strings overlap. The behavior is undefined if either dest is not a pointer to a character array or src is not a pointer to a null-terminated byte string. The behavior is undefined if the size of the character array pointed to by dest <= strlen(src, destsz)

Parameters

dst	pointer to the character array to write to
src	pointer to the null-terminated byte string to copy from

Returns

a copy of dest

Definition at line 26 of file strcpy.c.

{
    const size_t length = strlen(src);
    //  The stpcpy() and strcpy() functions copy the string src to dst
    //  (including the terminating '\0' character).
    memcpy(dst, src, length + 1);
    //  The strcpy() and strncpy() functions return dst.
    return dst;
}

References memcpy(), and strlen().

Referenced by strxfrm().

Here is the caller graph for this function:

strcspn()

size_t strcspn	(	const char *	,
		const char *
	)

Definition at line 8 of file strcspn.c.

{
    const char* a = s;
    size_t byteset[32 / sizeof(size_t)];

    if(!c[0] || !c[1])
    {
        return (uintptr_t)(__strchrnul(s, *c) - (uintptr_t)a);
    }

    memset(byteset, 0, sizeof byteset);
    for(; *c && BITOP(byteset, *(const unsigned char*)c, |=); c++)
    {
        {
            ;
        }
    }
    for(; *s && !BITOP(byteset, *(const unsigned char*)s, &); s++)
    {
        {
            ;
        }
    }
    return (uintptr_t)s - (uintptr_t)a;
}

References __strchrnul(), BITOP, and memset().

Referenced by strpbrk().

Here is the caller graph for this function:

strdup()

char* strdup

(

const char *

str

)

Duplicate the passed in string str.

Returns a pointer to a new string which is a duplicate of the string str. Memory for the new string is obtained with malloc(3), and can be freed with free(3).

Parameters

str	a pointer to a string to duplicate

Returns

a pointer to the duplicated string on success. NULL if insufficient memory was available, with errno set to indicate cause of error.

Definition at line 42 of file strdup.c.

{
    char* copy = NULL;

    if(str)
    {
        size_t len = strlen(str) + 1;

        if((copy = malloc(len)) == NULL)
        {
            return (NULL);
        }

        memcpy(copy, str, len);
    }

    return (copy);
}

References malloc(), memcpy(), NULL, and strlen().

strerror()

char* strerror

(

int

)

Definition at line 17 of file strerror.c.

{
    const char* s = NULL;
    int i;

    for(i = 0; errid[i] && errid[i] != err_no; i++)
    {
    }

    for(s = errmsg; i; s++, i--)
    {
        for(; *s; s++)
        {
        }
    }
    return (char*)(uintptr_t)s;
}

References errid, errmsg, and NULL.

Referenced by strerror_r().

Here is the caller graph for this function:

strerror_r()

int strerror_r	(	int	,
		char *	,
		size_t
	)

Definition at line 5 of file strerror_r.c.

{
    int r = 0;
    char* err_msg = strerror(err_no);
    size_t length = strlen(err_msg);

    assert(buffer);

    if(length >= buffer_size)
    {
        if(buffer_size)
        {
            // -1 so we don't copy an extra byte...
            memcpy(buffer, err_msg, buffer_size - 1);
            // since we will null terminate the string
            buffer[buffer_size - 1] = 0;
        }

        r = ERANGE;
    }
    else
    {
        // +1 for null termination
        memcpy(buffer, err_msg, length + 1);
    }

    return r;
}

References assert, ERANGE, memcpy(), strerror(), and strlen().

strlen()

size_t strlen

(

const char *

str

)

Returns the length of the given null-terminated byte string.

Returns the length of the given null-terminated byte string, that is, the number of characters in a character array whose first element is pointed to by str up to and not including the first null character.

The behavior is undefined if str is not a pointer to a null-terminated byte string.

Parameters

str	pointer to the null-terminated byte string to be examined

Returns

The length of the null-terminated byte string str.

Definition at line 77 of file strlen.c.

{
    const char* p;
    const unsigned long* lp;

    /* Skip the first few bytes until we have an aligned p */
    for(p = str; (uintptr_t)p & LONGPTR_MASK; p++)
    {
        if(*p == '\0')
        {
            return ((uintptr_t)p - (uintptr_t)str);
        }
    }

    /* Scan the rest of the string using word sized operation */
    // Cast to void to prevent alignment warning
    for(lp = (const unsigned long*)(const void*)p;; lp++)
    {
        if((*lp - mask01) & mask80)
        {
            p = (const char*)(lp);
            testbyte(0);
            testbyte(1);
            testbyte(2);
            testbyte(3);
#if(LONG_BIT >= 64)
            testbyte(4);
            testbyte(5);
            testbyte(6);
            testbyte(7);
#endif
        }
    }

    /* NOTREACHED */
    // return (0);
}

References LONGPTR_MASK, and testbyte.

Referenced by __strchrnul(), strcat(), strcpy(), strdup(), strerror_r(), strncat(), strnstr(), strrchr(), and strxfrm().

Here is the caller graph for this function:

strncat()

char* strncat	(	char *__restrict	dst,
		const char *__restrict	src,
		size_t	maxlen
	)

Appends at most maxlen characters from the character array pointed to by src, to the end of the null-terminated byte string pointed to by dest.

Appends at most count characters from the character array pointed to by src, stopping if the null character is found, to the end of the null-terminated byte string pointed to by dest. The character src[0] replaces the null terminator at the end of dest. The terminating null character is always appended in the end (so the maximum number of bytes the function may write is maxlen+1).

The behavior is undefined if the destination array is not large enough for the contents of both src and dest and the terminating null character. The behavior is undefined if the strings overlap. The behavior is undefined if either dest or src is not a pointer to a null-terminated byte string.

Parameters

dst	pointer to the null-terminated byte string to append to
src	pointer to the null-terminated byte string to copy from
maxlen	maximum number of characters to copy

Returns

a copy of dest

Definition at line 26 of file strncat.c.

{
    const size_t dstlen = strlen(dst);
    const size_t srclen = strnlen(src, maxlen);
    //  The strcat() and strncat() functions append a copy of the null-
    //  terminated string src to the end of the null-terminated string dst,
    //  then add a terminating '\0'.  The string dst must have sufficient
    //  space to hold the result.
    //
    //  The strncat() function appends not more than maxlen characters
    //  from src, and then adds a terminating '\0'.
    const size_t cpylen = srclen < maxlen ? srclen : maxlen;
    memcpy(dst + dstlen, src, cpylen);
    dst[dstlen + cpylen] = '\0';
    //  The strcat() and strncat() functions return dst.
    return dst;
}

References memcpy(), strlen(), and strnlen().

strncmp()

int strncmp	(	const char *	s1,
		const char *	s2,
		size_t	n
	)

Compares at most n characters of two possibly null-terminated arrays.

Compares at most count characters of two possibly null-terminated arrays. The comparison is done lexicographically.

The behavior is undefined when access occurs past the end of either array s1 or s2. The behavior is undefined when either s1 or s2 is the null pointer.

Parameters

s1	pointers to the null-terminated byte strings to compare
s2	pointers to the null-terminated byte strings to compare
n	maximum number of characters to compare

Returns

Negative value if s1 appears before s2 in lexicographical order. Zero if s1 and s2 compare equal, or if n is zero. Positive value if s1 appears after s2 in lexicographical order.

Definition at line 12 of file strncmp.c.

{
    int r = -1;

    if(s1 == s2)
    {
        // short circuit - same string
        return 0;
    }

    // I don't want to panic with a NULL ptr - we'll fall through and fail
    if(s1 != NULL && s2 != NULL)
    {
        // iterate through strings until they don't match, s1 ends, or n == 0
        for(; n && *s1 == *s2; ++s1, ++s2, n--)
        {
            if(*s1 == 0)
            {
                r = 0;
                break;
            }
        }

        // handle case where we didn't break early - set return code.
        if(n == 0)
        {
            r = 0;
        }
        else if(r != 0)
        {
            r = *s1 - *s2;
        }
    }

    return r;
}

References NULL.

Referenced by strnstr().

Here is the caller graph for this function:

strncpy()

char* strncpy	(	char *__restrict	dst,
		const char *__restrict	src,
		size_t	maxlen
	)

Copies at most maxlen characters of the character array pointed to by src to character array pointed to by dest.

Copies at most maxlen characters of the character array pointed to by src (including the terminating null character, but not any of the characters that follow the null character) to character array pointed to by dest. If maxlen is reached before the entire array src was copied, the resulting character array is not null-terminated. If, after copying the terminating null character from src, maxlen is not reached, additional null characters are written to dest until the total of maxlen characters have been written.

The behavior is undefined if the character arrays overlap, if either dest or src is not a pointer to a character array (including if dest or src is a null pointer), if the size of the array pointed to by dest is less than maxlen, or if the size of the array pointed to by src is less than maxlen and it does not contain a null character.

Parameters

dst	pointer to the character array to copy to
src	pointer to the character array to copy from
maxlen	maximum number of characters to copy

Returns

a copy of dest

Definition at line 26 of file strncpy.c.

{
    const size_t srclen = strnlen(src, maxlen);
    if(srclen < maxlen)
    {
        //  The stpncpy() and strncpy() functions copy at most maxlen
        //  characters from src into dst.
        memcpy(dst, src, srclen);
        //  If src is less than maxlen characters long, the remainder
        //  of dst is filled with '\0' characters.
        memset(dst + srclen, 0, maxlen - srclen);
    }
    else
    {
        //  Otherwise, dst is not terminated.
        memcpy(dst, src, maxlen);
    }
    //  The strcpy() and strncpy() functions return dst.
    return dst;
}

References memcpy(), memset(), and strnlen().

strndup()

char* strndup	(	const char *	str,
		size_t	n
	)

Duplicate n bytes of the passed in string str.

strndup is similar to

See also

strdup, but copies at most n bytes. If str is longer than n, only n bytes are copied, and a terminating null byte ('\0') is added.

Parameters

str	a pointer to a string to duplicate
n	maximum number of bytes to copy

Returns

a pointer to the duplicated string on success. NULL if insufficient memory was available, with errno set to indicate cause of error.

Definition at line 41 of file strndup.c.

{
    char* copy = NULL;

    if(str && n)
    {
        size_t len;

        for(len = 0; len < n && str[len]; len++)
        {
        }

        if((copy = malloc(len + 1)) == NULL)
        {
            return (NULL);
        }

        memcpy(copy, str, len);
        copy[len] = '\0';
    }

    return copy;
}

References malloc(), memcpy(), and NULL.

strnlen()

size_t strnlen	(	const char *	str,
		size_t	maxlen
	)

Returns the length of the given null-terminated byte string.

Same as

See also

strlen, except that the function returns zero if str is a null pointer and returns maxlen if the null character was not found in the first maxlen bytes of str.

The behavior is undefined if str points to a character array which lacks the null character and the size of that character array < maxlen; in other words, an erroneous value of maxlen does not expose impending buffer overflow.

Parameters

str	pointer to the null-terminated byte string to be examined
maxlen	maximum number of characters to examine

Returns

The length of the null-terminated byte string str on success, zero if str is a null pointer, maxlen if the null character was not found.

Definition at line 21 of file strnlen.c.

{
    const char* cp;

    for(cp = str; maxlen != 0 && *cp != '\0'; cp++, maxlen--)
    {
        {
            ;
        }
    }

    return (size_t)(cp - str);
}

Referenced by strncat(), and strncpy().

Here is the caller graph for this function:

strnstr()

char* strnstr	(	const char *	s,
		const char *	find,
		size_t	slen
	)

Finds the first occurrence of find in the initial slen characters of the object pointed to by s.

Locates the first occurrence of the null-terminated string find in the string s, where not more than slen characters are searched. Characters that appear after a ‘\0’ character are not searched.

The behavior is undefined if either find or s is not a pointer to a null-terminated byte string.

Parameters

s	pointer to the null-terminated byte string to examine
find	pointer to the null-terminated byte string to search for
slen	maxinum number of characters to search for

Returns

If find is an empty string, s is returned; if find occurs nowhere in s, NULL is returned; otherwise a pointer to the first character of the first occurrence of find is returned.

Definition at line 48 of file strnstr.c.

{
    char c;

    if((c = *find++) != '\0')
    {
        size_t len = strlen(find);
        do
        {
            char sc;
            do
            {
                if(slen-- < 1 || (sc = *s++) == '\0')
                {
                    {
                        return (NULL);
                    }
                }
            } while(sc != c);
            if(len > slen)
            {
                {
                    return (NULL);
                }
            }
        } while(strncmp(s, find, len) != 0);
        s--;
    }
    return ((char*)(uintptr_t)s);
}

References NULL, strlen(), and strncmp().

strpbrk()

char* strpbrk	(	const char *	,
		const char *
	)

Definition at line 3 of file strpbrk.c.

{
    s += strcspn(s, b);
    return *s ? (char*)(uintptr_t)s : 0;
}

References strcspn().

strrchr()

char* strrchr	(	const char *	s,
		int	c
	)

Finds the last occurrence of c in the null-terminated byte string pointed to by s.

Finds the last occurrence of c (after conversion to char as if by (char)c ) in the null-terminated byte string pointed to by s (each character interpreted as unsigned char). The terminating null character is considered to be a part of the string and can be found when searching for '\0'.

The behavior is undefined if s is not a pointer to a null-terminated byte string.

Parameters

s	pointer to the null-terminated byte string to be analyzed
c	character to search for

Returns

a pointer to the found character in s, or null pointer if no such character is found.

Definition at line 7 of file strrchr.c.

{
    return __memrchr(s, c, strlen(s) + 1);
}

References __memrchr(), and strlen().

strspn()

size_t strspn	(	const char *	,
		const char *
	)

Definition at line 7 of file strspn.c.

{
    const char* a = s;
    size_t byteset[32 / sizeof(size_t)] = {0};

    if(!c[0])
    {
        return 0;
    }

    if(!c[1])
    {
        for(; *s == *c; s++)
        {
            {
                ;
            }
        }
        return (uintptr_t)s - (uintptr_t)a;
    }

    for(; *c && BITOP(byteset, *(const unsigned char*)c, |=); c++)
    {
        {
            ;
        }
    }
    for(; *s && BITOP(byteset, *(const unsigned char*)s, &); s++)
    {
        {
            ;
        }
    }

    return (uintptr_t)s - (uintptr_t)a;
}

References BITOP.

strstr()

char* strstr	(	const char *	string,
		const char *	substring
	)

Finds the first occurrence of the substring in the string.

Finds the first occurrence of the null-terminated byte string pointed to by substring in the null-terminated byte string pointed to by string. The terminating null characters are not compared.

The behavior is undefined if either stirng or substring is not a pointer to a null-terminated byte string.

Parameters

string	pointer to the null-terminated byte string to examine
substring	pointer to the null-terminated byte string to search for

Returns

Pointer to the first character of the found substring in string, or NULL if no such substring is found. If substring points to an empty string, string is returned.

Definition at line 38 of file strstr.c.

{
    const char *a, *b;

    /* First scan quickly through the two strings looking for a
     * single-character match.  When it's found, then compare the
     * rest of the substring.
     */

    b = substring;

    if(*b == 0)
    {
        return (char*)(uintptr_t)string;
    }

    for(; *string != 0; string += 1)
    {
        if(*string != *b)
        {
            continue;
        }

        a = string;

        while(1)
        {
            if(*b == 0)
            {
                return (char*)(uintptr_t)string;
            }
            if(*a++ != *b++)
            {
                break;
            }
        }

        b = substring;
    }

    return NULL;
}

References NULL.

strtok()

char* strtok	(	char *	s,
		const char *	delim
	)

Finds the next token in a null-terminated byte string pointed to by s.

Finds the next token in a null-terminated byte string pointed to by s. The separator characters are identified by null-terminated byte string pointed to by delim. This function is designed to be called multiples times to obtain successive tokens from the same string.

• If s != NULL, the call is treated as the first call to strtok for this particular string. The function searches for the first character which is not contained in delim.

The behavior is undefined if either s or delim is not a pointer to a null-terminated byte string.

Parameters

s	pointer to the null-terminated byte string to tokenize
delim	pointer to the null-terminated byte string identifying delimiters

Returns

Returns pointer to the beginning of the next token or NULL if there are no more tokens.

Definition at line 109 of file strtok.c.

{
    static char* last;

    return (__strtok_r(s, delim, &last));
}

References __strtok_r().

strxfrm()

size_t strxfrm	(	char *	__restrict,
		const char *	__restrict,
		size_t
	)