frzysk/42_minishell
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

save

Browse source
This commit is contained in:
mcolonna 2024-04-23 16:46:55 +02:00
parent 17770aa6ae
commit d26cd021f2
50 changed files with 1591 additions and 127 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

BIN
a.out
View file

Binary file not shown.

47
libft/Makefile Normal file
View file

@ -0,0 +1,47 @@
# The interesting part
NAME = libft.a
SRCS = ./
INCLUDES = ./
FUNCTIONS = \
isalpha isdigit isalnum isascii isprint \
toupper tolower \
strncmp strlen strlcpy strlcat strchr strrchr strnstr strdup \
strmapi striteri substr strjoin strtrim split \
memset bzero memcpy memmove memchr memcmp calloc \
atoi itoa \
putchar_fd putstr_fd putendl_fd putnbr_fd
FUNCTIONS_BONUS = \
lstnew lstadd_front lstsize lstlast lstadd_back \
lstdelone lstclear lstiter lstmap
CODE = $(addprefix ft_, $(FUNCTIONS))
CODE_BONUS = $(addprefix ft_, $(FUNCTIONS_BONUS))
# It works and I probably won't change it for the rest of my life
C_FILES = $(addsuffix .c,$(addprefix $(SRCS),$(CODE)))
O_FILES = $(addsuffix .o,$(addprefix $(SRCS),$(CODE)))
C_FILES_BONUS = $(addsuffix .c,$(addprefix $(SRCS),$(CODE_BONUS)))
O_FILES_BONUS = $(addsuffix .o,$(addprefix $(SRCS),$(CODE_BONUS)))
CC = cc -Wall -Wextra -Werror
AR = ar rcs
MAKE = make
all : $(NAME) bonus
$(NAME) : $(O_FILES)
$(AR) $(NAME) $(O_FILES)
%.o : %.c
$(CC) -I $(INCLUDES) -c $< -o $@
clean :
rm -f $(O_FILES) $(O_FILES_BONUS)
fclean : clean
rm -f $(NAME)
re : fclean all
bonus : $(O_FILES_BONUS)
$(AR) $(NAME) $(O_FILES_BONUS)
.PHONY : all clean fclean re bonus

50
libft/ft_atoi.c Normal file
View file

@ -0,0 +1,50 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_atoi.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/08/28 17:45:41 by mcolonna #+# #+# */
/* Updated: 2023/10/09 12:03:52 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
static int is_in(char c, char *chars)
{
int i;
i = 0;
while (chars[i])
{
if (c == chars[i])
return (1);
i++;
}
return (0);
}
int ft_atoi(const char *nptr)
{
int sign;
int i;
int r;
sign = 1;
i = 0;
r = 0;
while (is_in(nptr[i], " \f\n\r\t\v"))
i++;
if (is_in(nptr[i], "+-"))
{
if (nptr[i] == '-')
sign *= -1;
i++;
}
while (is_in(nptr[i], "0123456789"))
{
r = r * 10 + (nptr[i] - '0');
i++;
}
return (r * sign);
}

18
libft/ft_bzero.c Normal file
View file

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_bzero.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 13:10:31 by mcolonna #+# #+# */
/* Updated: 2023/10/03 13:12:35 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_bzero(void *s, size_t n)
{
ft_memset(s, '\0', n);
}

29
libft/ft_calloc.c Normal file
View file

@ -0,0 +1,29 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_calloc.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 13:41:02 by mcolonna #+# #+# */
/* Updated: 2023/10/09 15:58:33 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "libft.h"
void *ft_calloc(size_t nmemb, size_t size)
{
void *dest;
int len;
if ((long)nmemb * (long)size > (long)INT_MAX)
return (NULL);
len = size * nmemb;
dest = malloc(len);
if (!dest)
return (NULL);
ft_bzero(dest, len);
return (dest);
}

18
libft/ft_isalnum.c Normal file
View file

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isalnum.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/02 16:44:20 by mcolonna #+# #+# */
/* Updated: 2023/10/03 15:02:39 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_isalnum(int c)
{
return (ft_isdigit(c) || ft_isalpha(c));
}

16
libft/ft_isalpha.c Normal file
View file

@ -0,0 +1,16 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isalpha.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/02 16:44:20 by mcolonna #+# #+# */
/* Updated: 2023/10/02 16:46:27 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
int ft_isalpha(int c)
{
return ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'));
}

16
libft/ft_isascii.c Normal file
View file

@ -0,0 +1,16 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isascii.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/02 16:44:20 by mcolonna #+# #+# */
/* Updated: 2023/10/02 16:50:28 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
int ft_isascii(int c)
{
return ((c >= 0 && c <= 127));
}

16
libft/ft_isdigit.c Normal file
View file

@ -0,0 +1,16 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isdigit.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/02 16:44:20 by mcolonna #+# #+# */
/* Updated: 2023/10/02 16:47:07 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
int ft_isdigit(int c)
{
return (c >= '0' && c <= '9');
}

16
libft/ft_isprint.c Normal file
View file

@ -0,0 +1,16 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isprint.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/02 16:44:20 by mcolonna #+# #+# */
/* Updated: 2023/10/02 16:51:08 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
int ft_isprint(int c)
{
return (c >= 32 && c <= 126);
}

67
libft/ft_itoa.c Normal file
View file

@ -0,0 +1,67 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_itoa.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 13:51:10 by mcolonna #+# #+# */
/* Updated: 2023/10/04 16:49:44 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "libft.h"
static char get_digit_at(long pos_n, int i, int nb_len)
{
int w;
long ten_power;
w = nb_len - i - 1;
ten_power = 1;
while (w--)
ten_power *= 10;
return ('0' + pos_n / ten_power % 10);
}
static int get_nb_len(long pos_n)
{
int r;
long ten_powers;
r = 1;
ten_powers = 10;
while (pos_n >= ten_powers)
{
r++;
ten_powers *= 10;
}
return (r);
}
char *ft_itoa(int n)
{
long pos_n;
int sign;
int nb_len;
char *dest;
int i;
sign = (n >= 0) - (n < 0);
pos_n = (long)n * sign;
nb_len = get_nb_len(pos_n);
dest = malloc(((sign == -1) + nb_len + 1) * sizeof(char));
if (!dest)
return (NULL);
i = 0;
if (sign == -1)
dest[i++] = '-';
while (i - (sign == -1) < nb_len)
{
dest[i] = get_digit_at(pos_n, i - (sign == -1), nb_len);
i++;
}
dest[i] = '\0';
return (dest);
}

24
libft/ft_lstadd_back.c Normal file
View file

@ -0,0 +1,24 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstadd_back.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/04 16:24:03 by mcolonna #+# #+# */
/* Updated: 2023/10/05 12:56:42 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstadd_back(t_list **lst, t_list *new)
{
t_list *last;
last = ft_lstlast(*lst);
if (last)
last->next = new;
else
*lst = new;
}

19
libft/ft_lstadd_front.c Normal file
View file

@ -0,0 +1,19 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstadd_front.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/04 16:19:20 by mcolonna #+# #+# */
/* Updated: 2023/10/04 16:20:44 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstadd_front(t_list **lst, t_list *new)
{
new->next = *lst;
*lst = new;
}

25
libft/ft_lstclear.c Normal file
View file

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstclear.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/04 16:31:06 by mcolonna #+# #+# */
/* Updated: 2023/10/05 11:40:24 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstclear(t_list **lst, void (*del)(void *))
{
t_list *next;
while (*lst)
{
next = (*lst)->next;
ft_lstdelone(*lst, del);
*lst = next;
}
}

22
libft/ft_lstdelone.c Normal file
View file

@ -0,0 +1,22 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstdelone.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/04 16:28:18 by mcolonna #+# #+# */
/* Updated: 2023/10/05 12:55:39 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "libft.h"
void ft_lstdelone(t_list *lst, void (*del)(void *))
{
if (!lst)
return ;
(*del)(lst->content);
free(lst);
}

22
libft/ft_lstiter.c Normal file
View file

@ -0,0 +1,22 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstiter.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/04 16:36:27 by mcolonna #+# #+# */
/* Updated: 2023/10/04 16:37:48 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstiter(t_list *lst, void (*f)(void *))
{
while (lst)
{
(*f)(lst->content);
lst = lst->next;
}
}

22
libft/ft_lstlast.c Normal file
View file

@ -0,0 +1,22 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstlast.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/04 16:22:57 by mcolonna #+# #+# */
/* Updated: 2023/10/05 12:53:31 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_list *ft_lstlast(t_list *lst)
{
if (!lst)
return (NULL);
while (lst->next)
lst = lst->next;
return (lst);
}

38
libft/ft_lstmap.c Normal file
View file

@ -0,0 +1,38 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstmap.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/04 16:37:57 by mcolonna #+# #+# */
/* Updated: 2023/10/12 13:17:57 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_list *ft_lstmap(t_list *lst, void *(*f)(void *), void (*del)(void *))
{
t_list *dest;
t_list *new;
void *new_content;
dest = NULL;
if (!lst)
return (NULL);
while (lst)
{
new_content = (*f)(lst->content);
new = ft_lstnew(new_content);
if (!new)
{
(*del)(new_content);
ft_lstclear(&dest, del);
return (NULL);
}
ft_lstadd_back(&dest, new);
lst = lst->next;
}
return (dest);
}

26
libft/ft_lstnew.c Normal file
View file

@ -0,0 +1,26 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstnew.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/04 16:14:54 by mcolonna #+# #+# */
/* Updated: 2023/10/04 16:51:08 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "libft.h"
t_list *ft_lstnew(void *content)
{
t_list *r;
r = malloc(sizeof(t_list));
if (!r)
return (NULL);
r->content = content;
r->next = NULL;
return (r);
}

26
libft/ft_lstsize.c Normal file
View file

@ -0,0 +1,26 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstsize.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/04 16:21:29 by mcolonna #+# #+# */
/* Updated: 2023/10/04 16:44:08 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_lstsize(t_list *lst)
{
int i;
i = 0;
while (lst)
{
lst = lst->next;
i++;
}
return (i);
}

28
libft/ft_memchr.c Normal file
View file

@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memchr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 13:28:00 by mcolonna #+# #+# */
/* Updated: 2023/10/03 15:31:16 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void *ft_memchr(const void *s, int c, size_t n)
{
size_t i;
const char *s2 = s;
i = 0;
while (i < n)
{
if (s2[i] == (char) c)
return ((void *) s + i);
i++;
}
return (NULL);
}

25
libft/ft_memcmp.c Normal file
View file

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memcmp.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 13:37:06 by mcolonna #+# #+# */
/* Updated: 2023/10/09 12:00:22 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_memcmp(const void *s1, const void *s2, size_t n)
{
size_t i;
if (n == 0)
return (0);
i = 0;
while (i < n - 1 && ((unsigned char *)s1)[i] == ((unsigned char *)s2)[i])
i++;
return (((unsigned char *)s1)[i] - ((unsigned char *)s2)[i]);
}

30
libft/ft_memcpy.c Normal file
View file

@ -0,0 +1,30 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memcpy.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 13:12:53 by mcolonna #+# #+# */
/* Updated: 2023/10/16 13:40:19 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void *ft_memcpy(void *dest, const void *src, size_t n)
{
size_t i;
char *dest2;
char *src2;
dest2 = (char *)dest;
src2 = (char *)src;
i = 0;
while (i < n)
{
dest2[i] = src2[i];
i++;
}
return (dest);
}

31
libft/ft_memmove.c Normal file
View file

@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memmove.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 13:17:41 by mcolonna #+# #+# */
/* Updated: 2023/10/12 10:44:37 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void *ft_memmove(void *dest, const void *src, size_t n)
{
size_t i;
if (!dest || !src)
return (NULL);
i = 0;
while (i < n)
{
if (dest < src)
((char *)dest)[i] = ((char *)src)[i];
else
((char *)dest)[n - i - 1] = ((char *)src)[n - i - 1];
i++;
}
return (dest);
}

28
libft/ft_memset.c Normal file
View file

@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memset.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 13:05:27 by mcolonna #+# #+# */
/* Updated: 2023/10/03 15:27:09 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void *ft_memset(void *s, int c, size_t n)
{
size_t i;
char *dest;
dest = (char *)s;
i = 0;
while (i < n)
{
dest[i] = (char)c;
i++;
}
return (dest);
}

18
libft/ft_putchar_fd.c Normal file
View file

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putchar_fd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 14:25:02 by mcolonna #+# #+# */
/* Updated: 2023/10/03 14:29:09 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void ft_putchar_fd(char c, int fd)
{
write(fd, &c, 1);
}

20
libft/ft_putendl_fd.c Normal file
View file

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putendl_fd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 14:25:02 by mcolonna #+# #+# */
/* Updated: 2023/10/04 14:17:01 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
#include "libft.h"
void ft_putendl_fd(char *s, int fd)
{
write(fd, s, ft_strlen(s));
write(fd, "\n", 1);
}

40
libft/ft_putnbr_fd.c Normal file
View file

@ -0,0 +1,40 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putnbr_fd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 14:32:29 by mcolonna #+# #+# */
/* Updated: 2023/10/09 17:23:02 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include <limits.h>
#include "libft.h"
static void putunsigned(long nb, int fd)
{
if (nb == 0)
return ;
putunsigned(nb / 10, fd);
ft_putchar_fd((char)(nb % 10) + '0', fd);
}
void ft_putnbr_fd(int n, int fd)
{
long nb;
if (n < 0)
{
ft_putchar_fd('-', fd);
nb = -(long)n;
}
else
nb = n;
if (n == 0)
ft_putchar_fd('0', fd);
else
putunsigned(nb, fd);
}

19
libft/ft_putstr_fd.c Normal file
View file

@ -0,0 +1,19 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putstr_fd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 14:25:02 by mcolonna #+# #+# */
/* Updated: 2023/10/03 14:34:35 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
#include "libft.h"
void ft_putstr_fd(char *s, int fd)
{
write(fd, s, ft_strlen(s));
}

98
libft/ft_split.c Normal file
View file

@ -0,0 +1,98 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_split.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 11:47:18 by mcolonna #+# #+# */
/* Updated: 2023/10/12 13:24:04 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "libft.h"
static int count_until(char const *s, char const c)
{
int i;
i = 0;
while (s[i] && s[i] != c)
i++;
return (i);
}
static int count_words(char const *s, char c)
{
int i;
int r;
int in_a_word;
i = 0;
r = 0;
in_a_word = 0;
while (s[i])
{
if (s[i] == c)
{
in_a_word = 0;
}
else if (!in_a_word)
{
in_a_word = 1;
r++;
}
i++;
}
return (r);
}
static char **free_array(char ***array, int size)
{
int i;
i = 0;
while (i < size)
{
free((*array)[i]);
(*array)[i] = NULL;
i++;
}
free(*array);
*array = NULL;
return (NULL);
}
static void ignore_sep(char const *s, char c, int *i)
{
while (s[*i] == c)
(*i)++;
}
char **ft_split(char const *s, char c)
{
int size;
char **dest;
int i;
int str_i;
int len_until;
size = count_words(s, c);
dest = malloc((size + 1) * sizeof(char *));
if (!dest)
return (NULL);
i = -1;
str_i = 0;
while (++i < size)
{
ignore_sep(s, c, &str_i);
len_until = count_until(s + str_i, c);
dest[i] = ft_substr(s, str_i, len_until);
if (!dest[i])
return (free_array(&dest, i));
str_i += len_until;
}
dest[i] = NULL;
return (dest);
}

29
libft/ft_strchr.c Normal file
View file

@ -0,0 +1,29 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strchr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 10:43:17 by mcolonna #+# #+# */
/* Updated: 2023/10/10 13:17:35 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
char *ft_strchr(const char *s, int c)
{
int i;
i = 0;
while (s[i])
{
if (s[i] == c)
return ((char *)s + i);
i++;
}
if (s[i] == c)
return ((char *)s + i);
return (NULL);
}

35
libft/ft_strdup.c Normal file
View file

@ -0,0 +1,35 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strdup.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/08/30 09:18:39 by mcolonna #+# #+# */
/* Updated: 2023/10/03 11:27:46 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
char *ft_strdup(const char *s)
{
int len;
int i;
char *dest;
len = 0;
while (s[len])
len++;
dest = malloc((len + 1) * sizeof(char));
if (!dest)
return (NULL);
i = 0;
while (s[i])
{
dest[i] = s[i];
i++;
}
dest[i] = '\0';
return (dest);
}

25
libft/ft_striteri.c Normal file
View file

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_striteri.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 11:08:18 by mcolonna #+# #+# */
/* Updated: 2023/10/04 11:10:28 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
void ft_striteri(char *s, void (*f)(unsigned int, char *))
{
unsigned int i;
i = 0;
while (s[i])
{
(*f)(i, s + i);
i++;
}
}

42
libft/ft_strjoin.c Normal file
View file

@ -0,0 +1,42 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strjoin.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 11:31:45 by mcolonna #+# #+# */
/* Updated: 2023/10/04 11:25:38 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "libft.h"
char *ft_strjoin(char const *s1, char const *s2)
{
int len;
char *dest;
int i;
int j;
len = ft_strlen(s1) + ft_strlen(s2);
dest = malloc((len + 1) * sizeof(char));
if (!dest)
return (NULL);
i = 0;
while (s1[i])
{
dest[i] = s1[i];
i++;
}
j = 0;
while (s2[j])
{
dest[i] = s2[j];
i++;
j++;
}
dest[i] = '\0';
return (dest);
}

44
libft/ft_strlcat.c Normal file
View file

@ -0,0 +1,44 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlcat.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/08/28 10:40:23 by mcolonna #+# #+# */
/* Updated: 2023/10/09 16:20:20 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
static size_t min(size_t a, size_t b)
{
if (a < b)
return (a);
else
return (b);
}
size_t ft_strlcat(char *dest, const char *src, size_t size)
{
size_t dest_len;
size_t dest_i;
size_t src_i;
dest_len = min(ft_strlen(dest), size);
if (dest_len < size - 1)
{
dest_i = dest_len;
src_i = 0;
while (src[src_i] && size > 0 && dest_i < size - 1)
{
dest[dest_i] = src[src_i];
src_i++;
dest_i++;
}
if (size > 0)
dest[dest_i] = '\0';
}
return (dest_len + ft_strlen(src));
}

30
libft/ft_strlcpy.c Normal file
View file

@ -0,0 +1,30 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlcpy.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/08/25 20:39:39 by mcolonna #+# #+# */
/* Updated: 2023/10/09 11:44:13 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
size_t ft_strlcpy(char *dest, const char *src, size_t size)
{
size_t i;
i = 0;
while (src[i] && size > 0 && i < size - 1)
{
dest[i] = src[i];
i++;
}
if (i < size)
dest[i] = '\0';
while (src[i])
i++;
return (i);
}

23
libft/ft_strlen.c Normal file
View file

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlen.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/08/24 13:10:16 by mcolonna #+# #+# */
/* Updated: 2023/10/10 14:09:44 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
size_t ft_strlen(const char *s)
{
int i;
i = 0;
while (s[i])
i++;
return (i);
}

32
libft/ft_strmapi.c Normal file
View file

@ -0,0 +1,32 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strmapi.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 11:08:18 by mcolonna #+# #+# */
/* Updated: 2023/10/03 15:20:49 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "libft.h"
char *ft_strmapi(char const *s, char (*f)(unsigned int, char))
{
char *dest;
unsigned int i;
dest = malloc((ft_strlen(s) + 1) * sizeof(char));
if (!dest)
return (NULL);
i = 0;
while (s[i])
{
dest[i] = (*f)(i, s[i]);
i++;
}
dest[i] = '\0';
return (dest);
}

25
libft/ft_strncmp.c Normal file
View file

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strncmp.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/10 12:21:33 by mcolonna #+# #+# */
/* Updated: 2023/10/10 14:39:03 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_strncmp(const char *s1, const char *s2, size_t n)
{
unsigned int i;
if (n == 0)
return (0);
i = 0;
while (i < n - 1 && s1[i] && s1[i] == s2[i])
i++;
return ((unsigned char)s1[i] - (unsigned char)s2[i]);
}

47
libft/ft_strnstr.c Normal file
View file

@ -0,0 +1,47 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strnstr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 10:50:23 by mcolonna #+# #+# */
/* Updated: 2023/10/09 16:09:21 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
// Return 1 if there is 'little' at the pos 'i' of 'big', or else 0.
static int match(const char *big, const char *little, size_t len, size_t i)
{
int j;
j = 0;
while (little[j])
{
if (len <= i || big[i] != little[j])
return (0);
i++;
j++;
}
return (1);
}
char *ft_strnstr(const char *big, const char *little, size_t len)
{
size_t i;
i = 0;
if (!little[0])
return ((char *)big);
if (!big[i] || i >= len)
return (NULL);
while (!match(big, little, len, i))
{
i++;
if (!big[i] || i >= len)
return (NULL);
}
return ((char *)big + i);
}

31
libft/ft_strrchr.c Normal file
View file

@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strrchr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 10:43:17 by mcolonna #+# #+# */
/* Updated: 2023/10/10 13:16:58 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
char *ft_strrchr(const char *s, int c)
{
char *r;
int i;
r = NULL;
i = 0;
while (s[i])
{
if (s[i] == c)
r = (char *)s + i;
i++;
}
if (s[i] == c)
r = (char *)s + i;
return (r);
}

80
libft/ft_strtrim.c Normal file
View file

@ -0,0 +1,80 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strtrim.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 11:39:33 by mcolonna #+# #+# */
/* Updated: 2023/10/04 13:07:54 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "libft.h"
static int is_in(char const c, char const *set)
{
int i;
i = 0;
while (set[i])
{
if (set[i] == c)
return (1);
i++;
}
return (0);
}
static size_t get_length(char const *s1, char const *set)
{
size_t i;
size_t r;
size_t tmp;
i = 0;
while (is_in(s1[i], set))
i++;
r = 0;
tmp = 0;
while (s1[i])
{
if (is_in(s1[i], set))
{
tmp++;
}
else
{
r += tmp;
tmp = 0;
r++;
}
i++;
}
return (r);
}
char *ft_strtrim(char const *s1, char const *set)
{
size_t len;
char *dest;
size_t start;
size_t i;
len = get_length(s1, set);
dest = malloc((len + 1) * sizeof(char));
if (!dest)
return (NULL);
start = 0;
while (is_in(s1[start], set))
start++;
i = 0;
while (i < len)
{
dest[i] = s1[start + i];
i++;
}
dest[i] = '\0';
return (dest);
}

41
libft/ft_substr.c Normal file
View file

@ -0,0 +1,41 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_substr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/03 11:17:12 by mcolonna #+# #+# */
/* Updated: 2023/10/09 13:27:30 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "libft.h"
char *ft_substr(char const *s, unsigned int start, size_t len)
{
char *dest;
size_t s_len;
size_t dest_len;
size_t i;
s_len = ft_strlen(s);
if (s_len < start)
dest_len = 0;
else if (s_len < start + len)
dest_len = s_len - start;
else
dest_len = len;
dest = malloc((dest_len + 1) * sizeof(char));
if (!dest)
return (NULL);
i = 0;
while (i < dest_len)
{
dest[i] = s[start + i];
i++;
}
dest[i] = '\0';
return (dest);
}

18
libft/ft_tolower.c Normal file
View file

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_tolower.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/02 16:53:06 by mcolonna #+# #+# */
/* Updated: 2023/10/02 16:58:02 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
int ft_tolower(int c)
{
if (c >= 'A' && c <= 'Z')
return (c - 'A' + 'a');
return (c);
}

18
libft/ft_toupper.c Normal file
View file

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_toupper.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/02 16:53:06 by mcolonna #+# #+# */
/* Updated: 2023/10/02 16:56:52 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
int ft_toupper(int c)
{
if (c >= 'a' && c <= 'z')
return (c - 'a' + 'A');
return (c);
}

196
libft/libft.h Normal file
View file

@ -0,0 +1,196 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* libft.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mcolonna <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/02 11:46:15 by mcolonna #+# #+# */
/* Updated: 2023/10/10 14:11:08 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef LIBFT_H
# define LIBFT_H
# include <stddef.h>
# include <limits.h>
///// CHAR /////
// (In libc) Return 1 if the char 'c' is a specific type of char, or else 0.
int ft_isalpha(int c); // A-Za-z
int ft_isdigit(int c); // 0-9
int ft_isalnum(int c); // A-Za-z0-9
int ft_isascii(int c); // (0)-(127)
int ft_isprint(int c); // (32)-(126)
// (In libc) Return the uppercase/lowercase version of the letter,
// or the char itself if it's not a letter.
int ft_toupper(int c);
int ft_tolower(int c);
///// STR /////
// (In libc) Compare 2 strings until n
int ft_strncmp(const char *s1, const char *s2, size_t n);
// (In libc) Return the length of the string 's'.
size_t ft_strlen(const char *s);
// (In libc) Copy/Append src on dst.
// 'dst' will be 'size' chars max, including \0,
// except if 'dst' is already longer for strlcat().
// 1. Never do more than size.
// 2. Always end by \0, except if it doesn't respect 1.
size_t ft_strlcpy(char *dst, const char *src, size_t size);
size_t ft_strlcat(char *dst, const char *src, size_t size);
// (In libc) Return a pointer to the first of last char 'c' in 's',
// or return NULL if there aren't any.
char *ft_strchr(const char *s, int c); // First char.
char *ft_strrchr(const char *s, int c); // Last char.
// (In libc) Return a pointer to the first occurence
// of string 'little' in string 'big'.
// Don't look chars after 'size'.
char *ft_strnstr(const char *big, const char *little, size_t len);
// (In libc) Return an malloced duplicate of 's'.
// Uses: malloc
// Error: return NULL
char *ft_strdup(const char *s);
// (Perso) Apply 'f' on each char of the string 's' and returns the result.
// Uses: malloc
// Error: return NULL
char *ft_strmapi(char const *s, char (*f)(unsigned int, char));
// (Perso) Call 'f' for each char of 's'.
void ft_striteri(char *s, void (*f)(unsigned int, char *));
// (Perso) Return the substring of 's' which starts at 'start'
// and is of length 'len'.
// Don't take chars after the end of the string.
// Uses: malloc
// Error: return NULL
char *ft_substr(char const *s, unsigned int start, size_t len);
// (Perso) Concatenate the two strings.
// Uses: malloc
// Error: return NULL
char *ft_strjoin(char const *s1, char const *s2);
// (Perso) Remove the characters 'set' from the beginning
// and the end of the string.
// Uses: malloc
// Error: return NULL
char *ft_strtrim(char const *s1, char const *set);
// (Perso) Split 's' by the chars 'c'.
// Return an array ended by NULL.
// Uses: malloc
// Error: return NULL
char **ft_split(char const *s, char c);
///// MEM /////
// (In libc) Fills 's' with 'n' times the char 'c'.
// Return 'c'.
void *ft_memset(void *s, int c, size_t n);
// (In libc) Just ft_memset(s, '\0', n) lol.
void ft_bzero(void *s, size_t n);
// (In libc) Copy 'n' bytes from 'src' to 'dest'.
// The 'src' and 'dest' areas mustn't overlap.
// Return 'dest'.
void *ft_memcpy(void *dest, const void *src, size_t n);
// (In libc) Same, but the areas can overlap.
// Return 'dest'.
void *ft_memmove(void *dest, const void *src, size_t n);
// (In libc) Find the character 'c' in 's', 's' being of length 'n'.
// NULL if none.
void *ft_memchr(const void *s, int c, size_t n);
// (In libc) Compare 'n' bytes of 's1' and 's2'.
int ft_memcmp(const void *s1, const void *s2, size_t n);
// (In libc) Alloc an array of 'size' elements with each element
// being of size 'size'.
// Uses: malloc
// Error: return NULL
void *ft_calloc(size_t nmemb, size_t size);
///// CAST /////
// (In libc) Cast a string to an int.
// /[ \f\n\r\t\v]*[-+]?[0-9]*.*/
int ft_atoi(const char *nptr);
// (Perso) Cast an int to a string.
// Uses: malloc
// Error: return NULL
char *ft_itoa(int n);
///// WRITE /////
// (Perso) Write the char/string on the file descriptor 'fd'.
// Uses: write
void ft_putchar_fd(char c, int fd);
void ft_putstr_fd(char *s, int fd);
// (Perso) Write the string 's' followed by a newline.
// Uses: write
void ft_putendl_fd(char *s, int fd);
// (Perso) Write the number 'n'.
// Uses: write
void ft_putnbr_fd(int n, int fd);
typedef struct s_list
{
void *content;
struct s_list *next;
} t_list;
///// BONUS /////
// Create an malloced list of size = 1: {content}
// Uses: malloc
// Error: return NULL
t_list *ft_lstnew(void *content);
// Add 'new' at the beginning of the list.
void ft_lstadd_front(t_list **lst, t_list *new);
// Get the length of the list.
int ft_lstsize(t_list *lst);
// Return the last node of the list.
t_list *ft_lstlast(t_list *lst);
// Add 'new' at the end of the list.
void ft_lstadd_back(t_list **lst, t_list *new);
// Apply 'del' on the element's content, then free lst.
// Uses: free
void ft_lstdelone(t_list *lst, void (*del)(void *));
// Free every element's content with del and free the elements.
// *lst will be set to NULL.
// Uses: free
void ft_lstclear(t_list **lst, void (*del)(void *));
// Apply f on the content of each node.
void ft_lstiter(t_list *lst, void (*f)(void *));
// Apply f on the content of each node
// and create a new list with the resulting contents.
// Uses: free, malloc
// Error: return NULL
t_list *ft_lstmap(t_list *lst, void *(*f)(void *), void (*del)(void *));
#endif

12
main.c
View file

@ -2,9 +2,11 @@
void execclear(char *p, char **envp)
{
execve(p, &p, envp);
(void)p;
(void)envp;
}
// Print hi :D
static void print_hi(void)
{
printf("Welcome to____________________________________\n");
@ -48,7 +50,11 @@ void hello_message(char **path, char **envp)
execclear(p[i], envp);
}
int main(char **envp)
int main(int argc, char **argv, char **envp)
{
char **path = get_path(envp);
}
(void)argc;
(void)argv;
(void)path;
}

18
minish.h
View file

@ -7,16 +7,18 @@
# include <strings.h>
# include <stdio.h>
# include <sys/types.h>
# include "libft.h"
///// PATH /////
// Get the PATH values.
// Return a list of strings ended by NULL.
char **get_path(char **envp);
// ??? TODO
int search_path(char **path);
// Copy the path list.
char **cp_path(char **path);
char *ft_substr(char const *s, unsigned int start, size_t len);
char *ft_strjoin(char const *s1, char const *s2);
int ft_strncmp(char *s1, char *s2, size_t n);
char **ft_split(char const *s, char c);
size_t ft_strlen(char const *s);
char *ft_strdup(const char *s);
#endif
#endif

4
path.c
View file

@ -6,7 +6,7 @@
/* By: jschaft <cecile.schaft@orange.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/16 12:07:26 by jschaft #+# #+# */
/* Updated: 2024/04/23 15:08:11 by jschaft ### ########.fr */
/* Updated: 2024/04/23 16:24:57 by mcolonna ### ########.fr */
/* */
/* ************************************************************************** */
@ -56,6 +56,6 @@ char **cp_path(char **path)
re[i] = ft_strdup(path[i]);
i++;
}
re[i] == NULL;
re[i] = NULL;
return (re);
}

114
util.c
View file

@ -1,114 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* util.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jschaft <cecile.schaft@orange.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/16 12:07:26 by jschaft #+# #+# */
/* Updated: 2024/04/23 16:00:41 by jschaft ### ########.fr */
/* */
/* ************************************************************************** */
#include "minish.h"
size_t ft_strlen(char const *s)
{
int i;
i = 0;
while (s[i] != '\0')
i++;
return (i);
}
int ft_strncmp(char *s1, char *s2, size_t n)
{
int i;
unsigned char *st1;
unsigned char *st2;
i = 0;
st1 = (unsigned char *)s1;
st2 = (unsigned char *)s2;
if (n == 0)
{
return (0);
}
while (st1[i] == st2[i] && st1[i] != '\0' && st2[i] != '\0'
&& i < (int)n - 1)
i++;
return (st1[i] - st2[i]);
}
char *ft_substr(char const *s, unsigned int start, size_t len)
{
int i;
char *null_re;
char *re;
i = 0;
null_re = malloc(sizeof(char));
re = malloc(sizeof(char) * (len + 1));
if (re == NULL || null_re == NULL)
return (NULL);
null_re[0] = '\0';
if (start >= ft_strlen(s))
return (null_re);
while (s[i + start] != '\0' && i < (int)len)
{
re[i] = s[i + start];
i++;
}
re[i] = '\0';
return (re);
}
char *ft_strjoin(char const *s1, char const *s2)
{
int i;
int y;
int size;
char *re;
i = 0;
y = 0;
size = ft_strlen(s1) + ft_strlen(s2) + 1;
re = malloc(sizeof(char) * size);
if (re == NULL)
return (NULL);
while (s1[i] != '\0')
{
re[i] = s1[i];
i++;
}
while (s2[y] != '\0')
{
re[i + y] = s2[y];
y++;
}
re[i + y] = '\0';
return (re);
}
char *ft_strdup(const char *s)
{
int i;
int len;
char *re;
len = 0;
while (s[len] != '\0')
len++;
re = malloc(sizeof(char) * (len + 1));
if (re == NULL)
return (NULL);
i = 0;
while (i < len)
{
re[i] = s[i];
i++;
}
re[i] = '\0';
return (re);
}