nalebrun/mmoat
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

base struct

Browse Source
This commit is contained in:
gazhonsepaskwa
2025-01-13 13:21:53 +01:00
parent a7e1a55200
commit 09c2cb5b3e
47 changed files with 1835 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
lib/libft/srcs/aloc/ft_calloc.c Normal file
View File

@@ -0,0 +1,27 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_calloc.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/14 15:18:45 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:14:20 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
void *ft_calloc(size_t count, size_t size)
{
void *ptr;
if ((size != 0 && ((count * size) / size != count)) || (size >= 2147483647
&& count >= 2147483647))
return (NULL);
ptr = malloc(count * size);
if (!ptr)
return (NULL);
ft_bzero(ptr, count * size);
return (ptr);
}

31
lib/libft/srcs/aloc/ft_free.c Normal file
View File

@@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_free.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/11/25 15:43:37 by nalebrun #+# #+# */
/* Updated: 2024/11/27 13:34:36 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
void ft_free(char **p)
{
if (p && *p)
{
free(*p);
*p = NULL;
}
}
void ft_free_v(void **p)
{
if (p && *p)
{
free(*p);
*p = NULL;
}
}

21
lib/libft/srcs/check/ft_isalnum.c Normal file
View File

@@ -0,0 +1,21 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isalnum.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/10 10:12:06 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:14:32 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
int ft_isalnum(int c)
{
if (ft_isalpha(c) || ft_isdigit(c))
return (1);
else
return (0);
}

21
lib/libft/srcs/check/ft_isalpha.c Normal file
View File

@@ -0,0 +1,21 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isalpha.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/09 14:23:31 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:14:36 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
int ft_isalpha(int a)
{
if ((a >= 65 && a <= 90) || (a >= 97 && a <= 122))
return (1);
else
return (0);
}

21
lib/libft/srcs/check/ft_isascii.c Normal file
View File

@@ -0,0 +1,21 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isascii.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/10 11:11:09 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:14:40 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
int ft_isascii(int c)
{
if (c >= 0 && c <= 127)
return (1);
else
return (0);
}

21
lib/libft/srcs/check/ft_isdigit.c Normal file
View File

@@ -0,0 +1,21 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isdigit.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/10 10:02:18 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:14:43 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
int ft_isdigit(int c)
{
if (c >= 48 && c <= 57)
return (1);
else
return (0);
}

21
lib/libft/srcs/check/ft_isprint.c Normal file
View File

@@ -0,0 +1,21 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isprint.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/10 11:23:47 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:14:48 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
int ft_isprint(int c)
{
if (c >= 32 && c <= 126)
return (1);
else
return (0);
}

72
lib/libft/srcs/format/ft_atoi.c Normal file
View File

@@ -0,0 +1,72 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_atoi.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/14 14:00:41 by nalebrun #+# #+# */
/* Updated: 2024/11/27 12:59:01 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
static int ft_isspace(char c)
{
if (c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f'
|| c == '\r')
return (1);
else
return (0);
}
static int ft_signer(char c, int *i)
{
int sign;
sign = 1;
if (c == '-')
{
sign *= -1;
(*i)++;
}
else if (c == '+')
(*i)++;
return (sign);
}
static int ft_signed(int sign)
{
if (sign == -1)
return (0);
else
return (-1);
}
int ft_atoi(const char *str)
{
int i;
int sign;
long res;
int current_digit;
if (!str)
return (-1);
res = 0;
i = 0;
while (ft_isspace(str[i]))
i++;
sign = ft_signer(str[i], &i);
while (str[i] == '0')
i++;
while (ft_isdigit(str[i]))
{
current_digit = str[i] - '0';
if (res > (LONG_MAX - current_digit) / 10)
return (ft_signed(sign));
res = (res * 10) + current_digit;
i++;
}
return ((int)(res *= sign));
}

67
lib/libft/srcs/format/ft_itoa.c Normal file
View File

@@ -0,0 +1,67 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_itoa.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/15 14:36:46 by nalebrun #+# #+# */
/* Updated: 2024/11/27 12:59:05 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
static char *ft_itoamem(long int n)
{
int i;
char *res;
int sign;
i = 0;
sign = 0;
if (n < 0)
{
sign = 1;
n *= -1;
}
while (n > 9)
{
n /= 10;
i++;
}
res = malloc(((i + 1) + sign + 1) * sizeof(char));
if (!res)
return (NULL);
res[i + 1 + sign] = '\0';
ft_memset(res, 48, ((i + 1) + sign) * sizeof(char));
return (res);
}
char *ft_itoa(int n)
{
char *res;
int i;
long int num;
num = n;
res = ft_itoamem(num);
if (!res)
return (NULL);
i = 0;
if (num < 0)
{
res[i] = '-';
num *= -1;
}
i = ft_strlen(res);
res[i] = '\0';
i--;
while (num > 9)
{
res[i--] = (num % 10) + '0';
num /= 10;
}
res[i] = num + '0';
return (res);
}

88
lib/libft/srcs/format/ft_split.c Normal file
View File

@@ -0,0 +1,88 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_split.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/11 16:15:47 by nalebrun #+# #+# */
/* Updated: 2024/11/27 12:58:41 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
static int ft_word_count(const char *str, char c)
{
int count;
if (!str)
return (0);
count = 0;
while (*str)
{
while (*str && *str == c)
str++;
if (*str && *str != c)
count++;
while (*str && *str != c)
str++;
}
return (count);
}
static char *malloccpy(const char *str, char c)
{
char *result;
int i;
i = 0;
while (str[i] && str[i] != c)
i++;
result = (char *)malloc(sizeof(char) * (i + 1));
if (!result)
return (NULL);
ft_strlcpy(result, str, i + 1);
return (result);
}
void free_tab(char **tab)
{
char **pos;
if (!tab)
return ;
pos = tab;
while (*pos != NULL)
free(*(pos++));
free(tab);
}
char **ft_split(const char *s, char c)
{
char **result;
int i;
int strs_len;
if (!s)
return (NULL);
strs_len = ft_word_count(s, c);
result = (char **)malloc(sizeof(char *) * (strs_len + 1));
if (!result)
return (NULL);
i = -1;
while (++i < strs_len)
{
while (*s && *s == c)
s++;
result[i] = malloccpy(s, c);
if (!result[i])
{
free_tab(result);
return (NULL);
}
s += ft_strlen(result[i]);
}
result[i] = 0;
return (result);
}

123
lib/libft/srcs/gnl/gnl.c Normal file
View File

@@ -0,0 +1,123 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* gnl.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/11/27 11:45:42 by nalebrun #+# #+# */
/* Updated: 2024/11/27 12:50:04 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
#include "gnl.h"
void free_buf(char **tab)
{
if (tab && *tab)
{
free(*tab);
*tab = NULL;
}
}
char *build_tab(char *tab, char *buffer, int i)
{
char *ret;
size_t t_len;
size_t b_len;
b_len = ft_gstrlen(buffer, -2);
t_len = ft_gstrlen(tab, i);
ret = malloc(b_len + t_len + 1);
if (!ret)
{
free(tab);
return (NULL);
}
if (tab)
{
ft_strlcpy(ret, tab, t_len + 1);
ft_strlcat(&ret[t_len], buffer, b_len + t_len + 1);
free(tab);
}
else
ft_strlcpy(ret, buffer, b_len + 1);
return (ret);
}
char *get_the_line(char **tab, int i)
{
char *line;
char *new_tab;
size_t len;
char *nl_pos;
nl_pos = ft_strichr(*tab, '\n', i);
if (!nl_pos)
return (NULL);
len = nl_pos - *tab + 1;
line = malloc(len + 1);
if (!line)
return (NULL);
ft_strlcpy(line, *tab, len + 1);
line[len] = '\0';
new_tab = ft_strdup(*tab + len);
if (!new_tab)
{
free(line);
return (NULL);
}
free(*tab);
*tab = new_tab;
return (line);
}
int read_file(int fd, char **tab, int i)
{
char buffer[BUFFER_SIZE + 1];
ssize_t bytes_read;
bytes_read = read(fd, buffer, BUFFER_SIZE);
if (bytes_read <= 0)
{
if (bytes_read == -1)
free_buf(&tab[fd]);
return (bytes_read);
}
buffer[bytes_read] = '\0';
tab[fd] = build_tab(tab[fd], buffer, i);
if (!tab[fd])
return (-1);
return (bytes_read);
}
char *get_next_line(int fd)
{
static char *tab[256];
char *next_line;
int i;
i = -1;
next_line = NULL;
if (fd < 0 || fd >= 256 || BUFFER_SIZE == 0)
return (NULL);
while (++i || 1)
{
next_line = get_the_line(&tab[fd], i);
if (next_line)
return (next_line);
if (read_file(fd, tab, i) <= 0)
break ;
}
if (tab[fd] && *tab[fd])
{
next_line = tab[fd];
tab[fd] = NULL;
return (next_line);
}
free(tab[fd]);
tab[fd] = NULL;
return (NULL);
}

21
lib/libft/srcs/gnl/gnl.h Normal file
View File

@@ -0,0 +1,21 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* gnl.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/11/27 12:46:20 by nalebrun #+# #+# */
/* Updated: 2024/11/27 12:53:23 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef GNL_H
# define GNL_H
# include "../../libft.h"
size_t ft_gstrlen(const char *str, int j);
char *ft_strichr(const char *s, int c, int i);
#endif

63
lib/libft/srcs/gnl/gnl_utils.c Normal file
View File

@@ -0,0 +1,63 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* gnl_utils.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/11/27 12:48:02 by nalebrun #+# #+# */
/* Updated: 2024/11/27 12:53:32 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
#include "gnl.h"
size_t ft_gstrlen(const char *str, int j)
{
size_t i;
i = 0;
if (!str)
return (0);
if (j == 0 || j == -2)
{
while (str[i])
i++;
return (i);
}
else
{
if (j > 0)
j--;
if (j != 0)
i += (BUFFER_SIZE * j) - 1;
while (str[i])
i++;
return (i);
}
}
char *ft_strichr(const char *s, int c, int i)
{
char *str;
char ch;
if (!s)
return (0);
if (i > 0)
i--;
ch = c;
str = (char *)s;
if (i != 0)
str += (BUFFER_SIZE * i) - 1;
while (*str)
{
if (*str == ch)
return (str);
str++;
}
if ((ch == 0) && (*str == 0))
return (str);
return (0);
}

26
lib/libft/srcs/mem/ft_bzero.c Normal file
View File

@@ -0,0 +1,26 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_bzero.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/10 16:07:05 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:14:55 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
void ft_bzero(void *s, size_t n)
{
char *ps;
size_t i;
if (n == 0 || !s)
return ;
ps = (char *)s;
i = 0;
while (i < n)
ps[i++] = 0;
}

26
lib/libft/srcs/mem/ft_memchr.c Normal file
View File

@@ -0,0 +1,26 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memchr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/14 11:38:35 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:14:59 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
char *ft_memchr(const void *s, int c, size_t n)
{
size_t i;
const unsigned char *ps;
ps = (const unsigned char *)s;
i = -1;
while (++i < n)
if (ps[i] == (unsigned char)c)
return ((char *)&ps[i]);
return (NULL);
}

28
lib/libft/srcs/mem/ft_memcmp.c Normal file
View File

@@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memcmp.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/14 11:54:32 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:15:04 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
int ft_memcmp(const void *s1, const void *s2, size_t n)
{
size_t i;
const unsigned char *ps1;
const unsigned char *ps2;
ps1 = (const unsigned char *)s1;
ps2 = (const unsigned char *)s2;
i = -1;
while (++i < n)
if (ps1[i] != ps2[i])
return (ps1[i] - ps2[i]);
return (0);
}

29
lib/libft/srcs/mem/ft_memcpy.c Normal file
View File

@@ -0,0 +1,29 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memcpy.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/11 09:21:39 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:15:09 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
void *ft_memcpy(void *dst, const void *src, size_t n)
{
unsigned char *pdst;
const unsigned char *psrc;
size_t i;
if (!dst && !src)
return (0);
pdst = (unsigned char *)dst;
psrc = (const unsigned char *)src;
i = -1;
while (++i < n)
pdst[i] = psrc[i];
return (dst);
}

37
lib/libft/srcs/mem/ft_memmove.c Normal file
View File

@@ -0,0 +1,37 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memmove.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/12 09:37:46 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:15:14 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
void *ft_memmove(void *dest, const void *src, size_t n)
{
unsigned char *pdst;
const unsigned char *psrc;
if (!dest && !src)
return (0);
pdst = (unsigned char *)dest;
psrc = (const unsigned char *)src;
if (pdst < psrc)
{
while (n--)
*pdst++ = *psrc++;
}
else
{
pdst += n;
psrc += n;
while (n--)
*(--pdst) = *(--psrc);
}
return (dest);
}

28
lib/libft/srcs/mem/ft_memset.c Normal file
View File

@@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memset.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/10 13:06:54 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:15:21 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
void *ft_memset(void *b, int c, size_t len)
{
unsigned char *ptr;
size_t i;
ptr = (unsigned char *)b;
i = 0;
while (i < len)
{
ptr[i] = c;
i++;
}
return (b);
}

100
lib/libft/srcs/print/ft_printf.c Normal file
View File

@@ -0,0 +1,100 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_printf.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/30 11:15:11 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:15:33 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
static int is_format(char c)
{
if (c == 'c' || c == 's' || c == 'p' || c == 'd' || c == 'i' || c == 'u' \
|| c == 'x' || c == 'X' || c == '%')
return (1);
return (0);
}
static int ft_put_p(va_list ap)
{
int count;
if (ft_put_s("0x") == -1)
return (-1);
count = ft_put_uli_base((unsigned long)va_arg(ap, void *), BASE16);
if (count == -1)
return (-1);
return (count + 2);
}
static int formater(va_list ap, const char *fstr)
{
if (*fstr == 'c')
return (ft_put_c((char)va_arg(ap, int)));
if (*fstr == 's')
return (ft_put_s((char *)va_arg(ap, char *)));
if (*fstr == 'p')
return (ft_put_p(ap));
if (*fstr == 'd' || *fstr == 'i')
return (ft_put_i((int)va_arg(ap, int)));
if (*fstr == 'u')
return (ft_put_ui((unsigned int)va_arg(ap, unsigned int)));
if (*fstr == 'x')
return (ft_put_ui_base((unsigned int)va_arg(ap, int), BASE16));
if (*fstr == 'X')
return (ft_put_ui_base((unsigned int)va_arg(ap, int), BASE16UP));
else
return (ft_put_s("%"));
}
int ft_printf(const char *fstr, ...)
{
va_list ap;
int count;
int tmp;
count = 0;
va_start(ap, fstr);
while (*fstr != 0)
{
if (*fstr == '%' && is_format(*(fstr + 1)))
tmp = formater(ap, ++fstr);
else
tmp = ft_put_c(*fstr);
if (tmp == -1)
return (-1);
count += tmp;
fstr++;
}
va_end(ap);
return (count);
}
int ft_debug(const char *fstr, ...)
{
va_list ap;
int count;
int tmp;
count = 0;
va_start(ap, fstr);
ft_put_s("\033[33m[DEBUG]\033[0m");
while (*fstr != 0)
{
if (*fstr == '%' && is_format(*(fstr + 1)))
tmp = formater(ap, ++fstr);
else
tmp = ft_put_c(*fstr);
if (tmp == -1)
return (-1);
count += tmp;
fstr++;
}
va_end(ap);
return (count);
}

74
lib/libft/srcs/print/ft_put.c Normal file
View File

@@ -0,0 +1,74 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_put.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/11/25 09:09:26 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:15:47 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
int ft_put_c(char c)
{
return (write(1, &c, 1));
}
int ft_put_s(char *s)
{
if (!s)
return (ft_put_s("(null)"));
return (write(1, s, ft_strlen(s)));
}
int ft_put_i(int n)
{
int count;
int tmp;
long nb;
nb = n;
count = 0;
if (nb < 0)
{
if (write(1, "-", 1) == -1)
return (-1);
count ++;
nb = -nb;
}
if (nb >= 10)
{
tmp = ft_put_i(nb / 10);
if (tmp == -1)
return (-1);
count += tmp;
}
tmp = ft_put_c((nb % 10) + '0');
if (tmp == -1)
return (-1);
return (tmp + count);
}
int ft_put_ui(unsigned int n)
{
char c;
int count;
int tmp;
count = 0;
if (n >= 10)
{
tmp = ft_put_ui(n / 10);
if (tmp == -1)
return (-1);
count += tmp;
}
c = (n % 10) + '0';
tmp = write(1, &c, 1);
if (tmp == -1)
return (-1);
return (tmp + count);
}

54
lib/libft/srcs/print/ft_put_fd.c Normal file
View File

@@ -0,0 +1,54 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_put_fd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/11/25 16:07:21 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:40:00 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
void ft_put_i_fd(int n, int fd)
{
char c;
if (n == -2147483648)
{
write(fd, "-2147483648", 11);
return ;
}
if (n < 0)
{
write(fd, "-", 1);
n = -n;
}
if (n >= 10)
{
ft_put_i_fd(n / 10, fd);
}
c = (n % 10) + '0';
write(fd, &c, 1);
}
void ft_put_s_fd(char *s, int fd)
{
if (!s)
return ;
write(fd, s, ft_strlen(s));
}
void ft_put_c_fd(char c, int fd)
{
write(fd, &c, 1);
}
void ft_error(char *e)
{
ft_put_s_fd(RED, 2);
ft_put_s_fd(e, 2);
ft_put_s_fd(RESET, 2);
}

54
lib/libft/srcs/print/ft_put_u_base.c Normal file
View File

@@ -0,0 +1,54 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_put_u_base.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/11/25 09:01:21 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:15:43 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
int ft_put_ui_base(unsigned int nbr, char *base)
{
unsigned int base_len;
int count;
int tmp;
count = 0;
base_len = ft_strlen(base);
if (base_len < 2)
return (0);
if (nbr >= base_len)
{
tmp = ft_put_ui_base(nbr / base_len, base);
if (tmp == -1)
return (-1);
count += tmp;
}
tmp = write(1, &base[nbr % base_len], 1);
if (tmp == -1)
return (-1);
return (tmp + count);
}
int ft_put_uli_base(unsigned long int nbr, char *base)
{
unsigned long base_len;
int count;
int tmp;
count = 0;
base_len = ft_strlen(base);
if (base_len < 2)
return (0);
if (nbr >= base_len)
count += ft_put_uli_base(nbr / base_len, base);
tmp = write(1, &base[nbr % base_len], 1);
if (tmp == -1)
return (-1);
return (tmp + count);
}

22
lib/libft/srcs/print/ft_putendl_fd.c Normal file
View File

@@ -0,0 +1,22 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putendl_fd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/15 18:01:01 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:15:50 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
void ft_putendl_fd(char *s, int fd)
{
int d;
d = 10;
write(fd, s, ft_strlen(s));
write(fd, &d, 1);
}

31
lib/libft/srcs/str/ft_strchr.c Normal file
View File

@@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strchr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/14 09:06:01 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:15:57 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
char *ft_strchr(const char *s, int c)
{
int i;
char ch;
ch = c;
i = 0;
if (ch == '\0')
return ((char *)&s[ft_strlen(s)]);
while (s[i] != 0)
{
if (s[i] == ch)
return ((char *)&s[i]);
i++;
}
return (NULL);
}

30
lib/libft/srcs/str/ft_strdup.c Normal file
View File

@@ -0,0 +1,30 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strdup.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/14 15:38:09 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:16:02 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
char *ft_strdup(const char *s1)
{
char *out;
unsigned long int i;
out = ft_calloc(ft_strlen(s1) + 1, sizeof(char));
if (!out || !s1)
return (NULL);
i = 0;
while (s1[i])
{
out[i] = s1[i];
i++;
}
return (out);
}

24
lib/libft/srcs/str/ft_striteri.c Normal file
View File

@@ -0,0 +1,24 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_striteri.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/15 17:17:33 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:16:05 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
void ft_striteri(char *s, void (*f)(unsigned int, char *))
{
size_t i;
if (!s || !f)
return ;
i = -1;
while (s[++i])
f(i, &s[i]);
}

38
lib/libft/srcs/str/ft_strjoin.c Normal file
View File

@@ -0,0 +1,38 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strjoin.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/14 17:14:32 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:16:11 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
char *ft_strjoin(const char *s1, const char *s2)
{
char *out;
unsigned int i;
unsigned int j;
if (!s1 && !s2)
return (NULL);
if (!s1)
return (ft_strdup(s2));
if (!s2)
return (ft_strdup(s1));
out = ft_calloc(ft_strlen(s1) + ft_strlen(s2) + 1, sizeof(char));
if (!out)
return (NULL);
i = 0;
j = 0;
while (s1[j])
out[i++] = s1[j++];
j = 0;
while (s2[j])
out[i++] = s2[j++];
return (out);
}

32
lib/libft/srcs/str/ft_strlcat.c Normal file
View File

@@ -0,0 +1,32 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlcat.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/12 10:07:49 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:16:15 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
size_t ft_strlcat(char *dst, const char *src, size_t dstsize)
{
size_t dst_len;
size_t src_len;
size_t i;
if (!dst || !src)
return (0);
dst_len = ft_strlen(dst);
src_len = ft_strlen(src);
if (dstsize <= dst_len)
return (dstsize + src_len);
i = -1;
while (src[++i] && (dst_len + i) < (dstsize - 1))
dst[dst_len + i] = src[i];
dst[dst_len + i] = '\0';
return (dst_len + src_len);
}

28
lib/libft/srcs/str/ft_strlcpy.c Normal file
View File

@@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlcpy.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/12 10:07:49 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:16:20 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
size_t ft_strlcpy(char *dst, const char *src, size_t dstsize)
{
size_t i;
if (!dst || !src)
return (0);
if (dstsize == 0)
return (ft_strlen(src));
i = -1;
while (++i < dstsize - 1 && src[i])
dst[i] = src[i];
dst[i] = 0;
return (ft_strlen(src));
}

25
lib/libft/srcs/str/ft_strlen.c Normal file
View File

@@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlen.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/10 12:01:43 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:16:24 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
size_t ft_strlen(const char *s)
{
size_t i;
if (!s)
return (0);
i = 0;
while (s[i] != 0)
i++;
return (i);
}

32
lib/libft/srcs/str/ft_strmapi.c Normal file
View File

@@ -0,0 +1,32 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strmapi.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/15 16:32:03 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:16:28 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
char *ft_strmapi(char const *s, char (*f)(unsigned int, char))
{
size_t len;
unsigned int i;
char *out;
if (!s || !f)
return (NULL);
len = ft_strlen(s);
out = (char *)ft_calloc(len + 1, sizeof(char));
if (!out)
return (NULL);
i = -1;
while (++i < len)
out[i] = f(i, s[i]);
out[len] = '\0';
return (out);
}

33
lib/libft/srcs/str/ft_strncmp.c Normal file
View File

@@ -0,0 +1,33 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strncmp.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/14 10:58:07 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:16:32 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
int ft_strncmp(const char *s1, const char *s2, size_t n)
{
size_t i;
unsigned char *ss1;
unsigned char *ss2;
if (!s1 || !s2)
return (0);
i = 0;
ss1 = (unsigned char *)s1;
ss2 = (unsigned char *)s2;
if (n == 0)
return (0);
while (i < n && ss1[i] && ss2[i] && ss1[i] == ss2[i])
i++;
if (i == n)
return (0);
return (ss1[i] - ss2[i]);
}

37
lib/libft/srcs/str/ft_strnstr.c Normal file
View File

@@ -0,0 +1,37 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strnstr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/14 12:45:20 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:16:35 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
char *ft_strnstr(const char *haystack, const char *needle, size_t len)
{
size_t i;
size_t j;
i = 0;
if (!haystack || !needle)
return (NULL);
if (needle[0] == 0)
return ((char *)haystack);
while (haystack[i] && i < len)
{
j = 0;
while (haystack[i + j] == needle[j] && i + j < len)
{
j++;
if (needle[j] == 0)
return ((char *)(haystack + i));
}
i++;
}
return (NULL);
}

26
lib/libft/srcs/str/ft_strrchr.c Normal file
View File

@@ -0,0 +1,26 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strrchr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/14 09:06:01 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:16:38 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
char *ft_strrchr(const char *s, int c)
{
int i;
if (!s)
return (NULL);
i = ft_strlen(s) + 1;
while (--i >= 0)
if (s[i] == (char)c)
return ((char *)&s[i]);
return (NULL);
}

77
lib/libft/srcs/str/ft_strtrim.c Normal file
View File

@@ -0,0 +1,77 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strtrim.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/14 17:42:56 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:16:44 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
static int ft_instr(int c, char *str)
{
int i;
i = -1;
while (str[++i])
if (str[i] == c)
return (1);
return (0);
}
static int ft_gettrimstart(const char *str, const char *set)
{
int i;
i = 0;
while (ft_instr(str[i], (char *)set) && str[i])
i++;
return (i);
}
static int ft_gettrimend(const char *str, const char *set)
{
int i;
i = 0;
while (ft_instr(str[ft_strlen(str) - i - 1], (char *)set))
i++;
return (i);
}
static void trloop(char *cpy, const char *s1, size_t trimstart, size_t trimend)
{
size_t i;
i = 0;
while (i < ft_strlen(s1) - (trimstart + trimend))
{
cpy[i] = s1[trimstart + i];
i++;
}
cpy[i] = 0;
}
char *ft_strtrim(const char *s1, const char *set)
{
char *cpy;
size_t trimstart;
size_t trimend;
if (!s1 || !set)
return (NULL);
cpy = (char *)s1;
trimstart = ft_gettrimstart(s1, set);
if (trimstart == ft_strlen(s1))
return (ft_strdup(""));
trimend = ft_gettrimend(s1, set);
cpy = ft_calloc(ft_strlen(s1) - (trimstart + trimend) + 1, sizeof(char));
if (!cpy)
return (NULL);
trloop(cpy, s1, trimstart, trimend);
return (cpy);
}

37
lib/libft/srcs/str/ft_substr.c Normal file
View File

@@ -0,0 +1,37 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_substr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/14 16:17:16 by nalebrun #+# #+# */
/* Updated: 2024/11/25 16:16:49 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
char *ft_substr(const char *s, unsigned int start, size_t len)
{
char *sub;
size_t i;
if (!s)
return (NULL);
if (start >= ft_strlen(s))
return (ft_strdup(""));
if ((size_t)start + len > ft_strlen(s))
sub = ft_calloc(ft_strlen(s) - (size_t)start + 1, sizeof(char));
else
sub = ft_calloc(len + 1, sizeof(char));
if (!sub)
return (NULL);
i = 0;
while (sub && i < len && s[start + i] != 0)
{
sub[i] = s[start + i];
i++;
}
return (sub);
}

21
lib/libft/srcs/str/ft_tolower.c Normal file
View File

@@ -0,0 +1,21 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_tolower.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/12 12:07:21 by nalebrun #+# #+# */
/* Updated: 2024/11/27 12:58:25 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
int ft_tolower(int c)
{
if (c >= 65 && c <= 90)
return (c + 32);
else
return (c);
}

21
lib/libft/srcs/str/ft_toupper.c Normal file
View File

@@ -0,0 +1,21 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_toupper.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: nalebrun <nalebrun@student.s19.be> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/10/12 12:01:30 by nalebrun #+# #+# */
/* Updated: 2024/11/27 12:58:24 by nalebrun ### ########.fr */
/* */
/* ************************************************************************** */
#include "../../libft.h"
int ft_toupper(int c)
{
if (c >= 97 && c <= 122)
return (c - 32);
else
return (c);
}