string.h File Reference

#include <stddef.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.

Macros
#define	strcpy   dont_use_strcpy_use_strlcpy
#define	strncpy   dont_use_strncpy_use_strlcpy
#define	strcat   dont_use_strcat_use_strlcat
#define	strncat   dont_use_strncat_use_strlcat
#define	strtok   dont_use_strtok_use_strtok_r

Functions
void *	memcpy (void *, const void *, size_t)
void *	memmove (void *, const void *, size_t)
char *	strncat (char *, const char *, size_t)
int	memcmp (const void *, const void *, size_t)
int	strcmp (const char *, const char *)
void *	memchr (const void *, int, size_t)
char *	strchr (const char *, int)
size_t	strcspn (const char *, const char *)
char *	strpbrk (const char *, const char *)
char *	strrchr (const char *, int)
size_t	strspn (const char *, const char *)
char *	strstr (const char *, const char *)
void *	memset (void *, int, size_t)
size_t	strlen (const char *)
size_t	strlcpy (char *, const char *, size_t)
size_t	strlcat (char *, const char *, size_t)
char *	strtok_r (char *, const char *, char **)
size_t	strnlen (const char *, size_t)

Macro Definition Documentation

strcat

#define strcat   dont_use_strcat_use_strlcat

strcpy

#define strcpy   dont_use_strcpy_use_strlcpy

strncat

#define strncat   dont_use_strncat_use_strlcat

strncpy

#define strncpy   dont_use_strncpy_use_strlcpy

strtok

#define strtok   dont_use_strtok_use_strtok_r

Function Documentation

memchr()

void * memchr	(	const void *	block_,
		int	ch_,
		size_t	size
	)

                                                  {
    const unsigned char *block = block_;
    unsigned char ch = ch_;
 
    ASSERT (block != NULL || size == 0);
 
    for (; size-- > 0; block++)
        if (*block == ch)
            return (void *) block;
 
    return NULL;
}

memcmp()

int memcmp	(	const void *	a_,
		const void *	b_,
		size_t	size
	)

                                                     {
    const unsigned char *a = a_;
    const unsigned char *b = b_;
 
    ASSERT (a != NULL || size == 0);
    ASSERT (b != NULL || size == 0);
 
    for (; size-- > 0; a++, b++)
        if (*a != *b)
            return *a > *b ? +1 : -1;
    return 0;
}

Here is the caller graph for this function:

memcpy()

void * memcpy	(	void *	dst_,
		const void *	src_,
		size_t	size
	)

                                                   {
    unsigned char *dst = dst_;
    const unsigned char *src = src_;
 
    ASSERT (dst != NULL || size == 0);
    ASSERT (src != NULL || size == 0);
 
    while (size-- > 0)
        *dst++ = *src++;
 
    return dst_;
}

Here is the caller graph for this function:

memmove()

void * memmove	(	void *	dst_,
		const void *	src_,
		size_t	size
	)

                                                    {
    unsigned char *dst = dst_;
    const unsigned char *src = src_;
 
    ASSERT (dst != NULL || size == 0);
    ASSERT (src != NULL || size == 0);
 
    if (dst < src) {
        while (size-- > 0)
            *dst++ = *src++;
    } else {
        dst += size;
        src += size;
        while (size-- > 0)
            *--dst = *--src;
    }
 
    return dst;
}

Here is the caller graph for this function:

memset()

void * memset	(	void *	dst_,
		int	value,
		size_t	size
	)

                                            {
    unsigned char *dst = dst_;
 
    ASSERT (dst != NULL || size == 0);
 
    while (size-- > 0)
        *dst++ = value;
 
    return dst_;
}

Here is the caller graph for this function:

strchr()

char * strchr	(	const char *	string,
		int	c_
	)

                                    {
    char c = c_;
 
    ASSERT (string);
 
    for (;;)
        if (*string == c)
            return (char *) string;
        else if (*string == '\0')
            return NULL;
        else
            string++;
}

Here is the caller graph for this function:

strcmp()

int strcmp	(	const char *	a_,
		const char *	b_
	)

                                        {
    const unsigned char *a = (const unsigned char *) a_;
    const unsigned char *b = (const unsigned char *) b_;
 
    ASSERT (a != NULL);
    ASSERT (b != NULL);
 
    while (*a != '\0' && *a == *b) {
        a++;
        b++;
    }
 
    return *a < *b ? -1 : *a > *b;
}

Here is the caller graph for this function:

strcspn()

size_t strcspn	(	const char *	string,
		const char *	stop
	)

                                               {
    size_t length;
 
    for (length = 0; string[length] != '\0'; length++)
        if (strchr (stop, string[length]) != NULL)
            break;
    return length;
}

Here is the call graph for this function:

strlcat()

size_t strlcat	(	char *	dst,
		const char *	src,
		size_t	size
	)

                                                  {
    size_t src_len, dst_len;
 
    ASSERT (dst != NULL);
    ASSERT (src != NULL);
 
    src_len = strlen (src);
    dst_len = strlen (dst);
    if (size > 0 && dst_len < size) {
        size_t copy_cnt = size - dst_len - 1;
        if (src_len < copy_cnt)
            copy_cnt = src_len;
        memcpy (dst + dst_len, src, copy_cnt);
        dst[dst_len + copy_cnt] = '\0';
    }
    return src_len + dst_len;
}

Here is the call graph for this function:

strlcpy()

size_t strlcpy	(	char *	dst,
		const char *	src,
		size_t	size
	)

                                                  {
    size_t src_len;
 
    ASSERT (dst != NULL);
    ASSERT (src != NULL);
 
    src_len = strlen (src);
    if (size > 0) {
        size_t dst_len = size - 1;
        if (src_len < dst_len)
            dst_len = src_len;
        memcpy (dst, src, dst_len);
        dst[dst_len] = '\0';
    }
    return src_len;
}

Here is the call graph for this function:

Here is the caller graph for this function:

strlen()

size_t strlen

(

const char *

string

)

                            {
    const char *p;
 
    ASSERT (string);
 
    for (p = string; *p != '\0'; p++)
        continue;
    return p - string;
}

Here is the caller graph for this function:

strncat()

char * strncat	(	char *	,
		const char *	,
		size_t
	)

strnlen()

size_t strnlen	(	const char *	string,
		size_t	maxlen
	)

                                            {
    size_t length;
 
    for (length = 0; string[length] != '\0' && length < maxlen; length++)
        continue;
    return length;
}

Here is the caller graph for this function:

strpbrk()

char * strpbrk	(	const char *	string,
		const char *	stop
	)

                                               {
    for (; *string != '\0'; string++)
        if (strchr (stop, *string) != NULL)
            return (char *) string;
    return NULL;
}

Here is the call graph for this function:

strrchr()

char * strrchr	(	const char *	string,
		int	c_
	)

                                     {
    char c = c_;
    const char *p = NULL;
 
    for (; *string != '\0'; string++)
        if (*string == c)
            p = string;
    return (char *) p;
}

strspn()

size_t strspn	(	const char *	string,
		const char *	skip
	)

                                              {
    size_t length;
 
    for (length = 0; string[length] != '\0'; length++)
        if (strchr (skip, string[length]) == NULL)
            break;
    return length;
}

Here is the call graph for this function:

strstr()

char * strstr	(	const char *	haystack,
		const char *	needle
	)

                                                  {
    size_t haystack_len = strlen (haystack);
    size_t needle_len = strlen (needle);
 
    if (haystack_len >= needle_len) {
        size_t i;
 
        for (i = 0; i <= haystack_len - needle_len; i++)
            if (!memcmp (haystack + i, needle, needle_len))
                return (char *) haystack + i;
    }
 
    return NULL;
}

Here is the call graph for this function:

strtok_r()

char * strtok_r	(	char *	s,
		const char *	delimiters,
		char **	save_ptr
	)

                                                            {
    char *token;
 
    ASSERT (delimiters != NULL);
    ASSERT (save_ptr != NULL);
 
    /* If S is nonnull, start from it.
       If S is null, start from saved position. */
    if (s == NULL)
        s = *save_ptr;
    ASSERT (s != NULL);
 
    /* Skip any DELIMITERS at our current position. */
    while (strchr (delimiters, *s) != NULL) {
        /* strchr() will always return nonnull if we're searching
           for a null byte, because every string contains a null
           byte (at the end). */
        if (*s == '\0') {
            *save_ptr = s;
            return NULL;
        }
 
        s++;
    }
 
    /* Skip any non-DELIMITERS up to the end of the string. */
    token = s;
    while (strchr (delimiters, *s) == NULL)
        s++;
    if (*s != '\0') {
        *s = '\0';
        *save_ptr = s + 1;
    } else
        *save_ptr = s;
    return token;
}

Here is the call graph for this function:

Here is the caller graph for this function: