ft_string.h File Reference

#include <stddef.h>
#include <stdbool.h>

Include dependency graph for ft_string.h:

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

Go to the source code of this file.

Functions
size_t	ft_strlen (const char *s)
size_t	ft_strlcpy (char *dst, const char *src, size_t dstsize)
size_t	ft_strlcat (char *dst, const char *src, size_t dstsize)
char *	ft_strchr (const char *s, int c)
char *	ft_strrchr (const char *s, int c)
int	ft_strncmp (const char *s1, const char *s2, size_t n)
char *	ft_strnstr (const char *haystack, const char *needle, size_t len)
int	ft_atoi (const char *str)
bool	ft_atoi_strict (const char *str, const char **endptr, int *dst)
char *	ft_strdup (const char *s1)
char *	ft_substr (char const *s, unsigned int start, size_t len)
char *	ft_strjoin (char const *s1, char const *s2)
char *	ft_strtrim (char const *s1, char const *set)
char **	ft_split (char const *s, char c)
char *	ft_itoa (int n)
char *	ft_strmapi (char const *s, char(*f)(unsigned int, char))
void	ft_striteri (char *s, void(*f)(unsigned int, char *))
long	ft_strtol (const char *str, char **endptr, int base)
char *	ft_strndup (const char *s1, size_t n)
size_t	ft_strnlen (const char *str, size_t max_len)
int	get_numstr_base (char *buf, size_t num, int base, bool is_upper)

Function Documentation

ft_atoi()

int ft_atoi

(

const char *

str

)

Definition at line 16 of file ft_atoi.c.

{
    return ((int)ft_strtol(str, NULL, 10));
}

Here is the call graph for this function:

ft_atoi_strict()

bool ft_atoi_strict	(	const char *	str,
		const char **	endptr,
		int *	dst
	)

Definition at line 32 of file ft_atoi_strict.c.

{
    int sign;
 
    if (str == NULL || dst == NULL)
        return (false);
    if (*endptr != NULL)
        *endptr = str;
    sign = 1;
    if (*str == '-')
        sign = -1;
    if (*str == '-' || *str == '+')
        str++;
    if (*endptr != NULL)
        *endptr = str;
    if (!ft_isdigit(*str))
        return (false);
    *dst = 0;
    while (set_value(*str, dst, sign))
        str++;
    if (*endptr != NULL)
        *endptr = str;
    return (true);
}

Here is the call graph for this function:

ft_itoa()

char* ft_itoa

(

int

n

)

Definition at line 48 of file ft_itoa.c.

{
    char    num_str_buf[NUM_STR_BUF_LEN];
    int     buf_pos;
    long    long_n;
 
    if (n == 0)
        return (ft_strdup("0"));
    buf_pos = 0;
    long_n = ft_absl(n);
    while (long_n != 0)
    {
        num_str_buf[buf_pos++] = (long_n % 10) + '0';
        long_n /= 10;
    }
    if (n < 0)
        num_str_buf[buf_pos++] = '-';
    num_str_buf[buf_pos] = '\0';
    return (reverse_str(ft_strdup(num_str_buf)));
}

Here is the call graph for this function:

Here is the caller graph for this function:

ft_split()

char** ft_split	(	char const *	s,
		char	c
	)

Definition at line 51 of file ft_split.c.

{
    char        **p_p_ret;
    size_t      p_p_ret_index;
    const char  *p_top_to_dup;
 
    if (s == NULL)
        return (ft_calloc(1, sizeof(void *)));
    while (*s != '\0' && *s == c)
        s++;
    p_p_ret = ft_calloc(count_char(s, c) + 2, sizeof(void *));
    p_p_ret_index = 0;
    while (p_p_ret != NULL && *s != '\0')
    {
        p_top_to_dup = s;
        while (*s != '\0' && *s != c)
            s++;
        p_p_ret[p_p_ret_index]
            = ft_substr(p_top_to_dup, 0, (size_t)s - (size_t)p_top_to_dup);
        if (check_and_handle_alloc_error(p_p_ret, p_p_ret_index++))
            return (NULL);
        while (*s != '\0' && *s == c)
            s++;
    }
    return (p_p_ret);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ft_strchr()

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

Definition at line 15 of file ft_strchr.c.

{
    while (*s != (char)c && *s != '\0')
        s++;
    if (*s == (char)c)
        return ((char *)s);
    else
        return (NULL);
}

Here is the caller graph for this function:

ft_strdup()

char* ft_strdup

(

const char *

s1

)

Definition at line 16 of file ft_strdup.c.

{
    size_t  s1_len;
    char    *p_ret;
    char    *p_ret_top;
 
    s1_len = ft_strlen(s1);
    p_ret = (char *)malloc(s1_len + 1);
    p_ret_top = p_ret;
    if (p_ret == NULL)
        return (NULL);
    while (*s1 != '\0')
        *p_ret++ = *s1++;
    *p_ret = '\0';
    return (p_ret_top);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ft_striteri()

void ft_striteri	(	char *	s,
		void(*)(unsigned int, char *)	f
	)

Definition at line 16 of file ft_striteri.c.

{
    size_t  index;
 
    if (s == NULL || f == NULL)
        return ;
    index = 0;
    while (*s != '\0')
        f(index++, s++);
}

ft_strjoin()

char* ft_strjoin	(	char const *	s1,
		char const *	s2
	)

Definition at line 17 of file ft_strjoin.c.

{
    size_t  s1_len;
    size_t  s2_len;
    char    *p_ret;
 
    if (s1 == NULL)
        s1_len = 0;
    else
        s1_len = ft_strlen(s1);
    if (s2 == NULL)
        s2_len = 0;
    else
        s2_len = ft_strlen(s2);
    p_ret = malloc(s1_len + s2_len + 1);
    if (p_ret == NULL)
        return (NULL);
    ft_memmove(p_ret, s1, s1_len);
    ft_memmove(p_ret + s1_len, s2, s2_len);
    p_ret[s1_len + s2_len] = '\0';
    return (p_ret);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ft_strlcat()

size_t ft_strlcat	(	char *	dst,
		const char *	src,
		size_t	dstsize
	)

Definition at line 15 of file ft_strlcat.c.

{
    size_t  src_len;
    size_t  dest_len;
 
    dest_len = ft_strnlen(dest, size);
    src_len = ft_strlen(src);
    if (dest_len >= size)
        return (size + src_len);
    size -= dest_len;
    dest += dest_len;
    while (*src != '\0' && --size > 0)
        *(dest++) = *(src++);
    *dest = '\0';
    return (src_len + dest_len);
}

Here is the call graph for this function:

ft_strlcpy()

size_t ft_strlcpy	(	char *	dst,
		const char *	src,
		size_t	dstsize
	)

Definition at line 15 of file ft_strlcpy.c.

{
    size_t  src_size;
 
    src_size = ft_strlen(src);
    if (size == 0)
        return (src_size);
    if ((src_size + 1) < size)
        size = src_size + 1;
    while (--size > 0)
        *(dest++) = *(src++);
    *dest = '\0';
    return (src_size);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ft_strlen()

size_t ft_strlen

(

const char *

s

)

Definition at line 15 of file ft_strlen.c.

{
    size_t  len;
 
    len = 0;
    while (*str != '\0')
    {
        str++;
        len++;
    }
    return (len);
}

Here is the caller graph for this function:

ft_strmapi()

char* ft_strmapi	(	char const *	s,
		char(*)(unsigned int, char)	f
	)

Definition at line 15 of file ft_strmapi.c.

{
    char    *p_ret;
    size_t  index;
 
    if (s == NULL || *s == '\0')
        return (ft_strdup(""));
    p_ret = ft_strdup(s);
    if (f == NULL || p_ret == NULL)
        return (p_ret);
    index = 0;
    while (*s != '\0')
    {
        p_ret[index] = f(index, *s++);
        index++;
    }
    return (p_ret);
}

Here is the call graph for this function:

ft_strncmp()

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

Definition at line 16 of file ft_strncmp.c.

{
    if (n == 0)
        return (0);
    while (--n > 0 && *s1 == *s2 && *s1 != '\0')
    {
        s1++;
        s2++;
    }
    return (*((unsigned char *)s1) - *((unsigned char *)s2));
}

Here is the caller graph for this function:

ft_strndup()

char* ft_strndup	(	const char *	s1,
		size_t	n
	)

Definition at line 18 of file ft_strndup.c.

{
    size_t  s1_len;
    char    *p_ret;
    char    *p_ret_top;
 
    if (n <= 0)
        return (ft_strdup(""));
    s1_len = ft_minp(ft_strlen(s1), n);
    p_ret = (char *)malloc(s1_len + 1);
    p_ret_top = p_ret;
    if (p_ret == NULL)
        return (NULL);
    while (s1_len-- > 0)
        *p_ret++ = *s1++;
    *p_ret = '\0';
    return (p_ret_top);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ft_strnlen()

size_t ft_strnlen	(	const char *	str,
		size_t	max_len
	)

Definition at line 16 of file ft_strnlen.c.

{
    size_t  len;
 
    len = 0;
    while (len < max_len && *str != '\0')
    {
        str++;
        len++;
    }
    return (len);
}

Here is the caller graph for this function:

ft_strnstr()

char* ft_strnstr	(	const char *	haystack,
		const char *	needle,
		size_t	len
	)

Definition at line 15 of file ft_strnstr.c.

{
    size_t  pos;
 
    if (*needle == '\0')
        return ((char *)haystack);
    while (len > 0 && *haystack != '\0')
    {
        if (*haystack == *needle)
        {
            pos = 0;
            while (needle[pos] != '\0'
                && len > pos && haystack[pos] == needle[pos])
                pos++;
            if (needle[pos] == '\0')
                return ((char *)haystack);
        }
        haystack++;
        len--;
    }
    return (NULL);
}

ft_strrchr()

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

Definition at line 15 of file ft_strrchr.c.

{
    const char  *p_c_found;
 
    p_c_found = NULL;
    while (*s != '\0')
    {
        if (*s == (char)c)
            p_c_found = s;
        s++;
    }
    if (p_c_found != NULL)
        return ((char *)p_c_found);
    else if (c == '\0')
        return ((char *)s);
    else
        return (NULL);
}

ft_strtol()

long ft_strtol	(	const char *	str,
		char **	endptr,
		int	base
	)

Definition at line 69 of file ft_strtol.c.

{
    long    sign;
    long    value;
 
    sign = 1;
    value = 0;
    if (endptr != NULL)
        *endptr = (char *)str;
    if (!((2 <= base && base <= 36) || base == 0))
        return (0);
    while (((9 <= *str && *str <= 13) || *str == ' ') && *str != '\0')
        str++;
    if (*str == '-')
        sign = -1;
    else if (*str != '+' && !(('a' <= *str && *str <= 'z')
            || ('A' <= *str && *str <= 'Z') || ('0' <= *str && *str <= '9')))
        return (0);
    if (*str == '+' || *str == '-')
        str++;
    base = get_base(&str, base);
    while (set_value(*str, &value, sign, base))
        str++;
    if (endptr != NULL)
        *endptr = (char *)str;
    return (value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ft_strtrim()

char* ft_strtrim	(	char const *	s1,
		char const *	set
	)

Definition at line 16 of file ft_strtrim.c.

{
    size_t      s1_len;
    const char  *s1_end;
 
    if (s1 == NULL)
        return (NULL);
    if (set == NULL || *s1 == '\0')
        return (ft_strdup(s1));
    s1_len = ft_strlen(s1);
    s1_end = s1 + s1_len - 1;
    while (*s1 != '\0' && ft_strchr(set, *s1) != NULL)
        s1++;
    if (*s1 == '\0')
        return (ft_strdup(""));
    while (ft_strchr(set, *s1_end) != NULL)
        s1_end--;
    return (ft_strndup(s1, (size_t)s1_end - (size_t)s1 + 1));
}

Here is the call graph for this function:

ft_substr()

char* ft_substr	(	char const *	s,
		unsigned int	start,
		size_t	len
	)

Definition at line 16 of file ft_substr.c.

{
    if (s == NULL)
        return (NULL);
    if (len == 0 || ft_strlen(s) <= start)
        return (ft_strdup(""));
    return (ft_strndup(s + start, len));
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_numstr_base()

int get_numstr_base	(	char *	buf,
		size_t	num,
		int	base,
		bool	is_upper
	)

Definition at line 17 of file get_numstr_base.c.

{
    int     tmp;
    int     last_len;
    char    c;
 
    if (num == 0)
        return (0);
    last_len = get_numstr_base(buf, num / base, base, is_upper);
    tmp = num % base;
    if (tmp < 10)
        c = '0' + tmp;
    else if (is_upper)
        c = 'A' + tmp - 10;
    else
        c = 'a' + tmp - 10;
    buf[last_len] = c;
    return (last_len + 1);
}

Here is the call graph for this function:

Here is the caller graph for this function: