From b542d8adc073ce5242c9de1c8908079fc70c7b53 Mon Sep 17 00:00:00 2001 From: Hugo LAMY Date: Thu, 28 Nov 2019 13:51:50 +0100 Subject: [PATCH] correction memcpy pour le cas ou dst et src sont nuls --- .Makefile.swp | Bin 45056 -> 0 bytes .testresults.swp | Bin 12288 -> 0 bytes {srcs => srcd}/add/ft_any.c | 0 {srcs => srcd}/add/ft_arraymap.c | 0 {srcs => srcd}/add/ft_atoibase.c | 0 {srcs => srcd}/add/ft_convertbase.c | 0 {srcs => srcd}/add/ft_foreach.c | 0 {srcs => srcd}/add/ft_issort.c | 0 {srcs => srcd}/add/ft_memalloc.c | 0 {srcs => srcd}/add/ft_memdel.c | 0 {srcs => srcd}/add/ft_putchar.c | 0 {srcs => srcd}/add/ft_putendl.c | 0 {srcs => srcd}/add/ft_putnbr.c | 0 {srcs => srcd}/add/ft_putnbrbase.c | 0 {srcs => srcd}/add/ft_putnbrendl.c | 0 {srcs => srcd}/add/ft_putnbrendl_fd.c | 0 {srcs => srcd}/add/ft_putstr.c | 0 {srcs => srcd}/add/ft_strcat.c | 0 {srcs => srcd}/add/ft_strclr.c | 0 {srcs => srcd}/add/ft_strcmp.c | 0 {srcs => srcd}/add/ft_strcpy.c | 0 {srcs => srcd}/add/ft_strdel.c | 0 {srcs => srcd}/add/ft_strequ.c | 0 {srcs => srcd}/add/ft_striter.c | 0 {srcs => srcd}/add/ft_striteri.c | 0 {srcs => srcd}/add/ft_strjoinfree.c | 0 {srcs => srcd}/add/ft_strmap.c | 0 {srcs => srcd}/add/ft_strmultisplit.c | 0 {srcs => srcd}/add/ft_strncat.c | 0 {srcs => srcd}/add/ft_strncpy.c | 0 {srcs => srcd}/add/ft_strnequ.c | 0 {srcs => srcd}/add/ft_strnew.c | 0 {srcs => srcd}/add/ft_strstr.c | 0 {srcs => srcd}/bonus/ft_lstadd_back.c | 0 {srcs => srcd}/bonus/ft_lstadd_front.c | 0 {srcs => srcd}/bonus/ft_lstclear.c | 0 {srcs => srcd}/bonus/ft_lstdelone.c | 0 {srcs => srcd}/bonus/ft_lstiter.c | 0 {srcs => srcd}/bonus/ft_lstlast.c | 0 {srcs => srcd}/bonus/ft_lstmap.c | 0 {srcs => srcd}/bonus/ft_lstnew.c | 0 {srcs => srcd}/bonus/ft_lstsize.c | 0 {srcs => srcd}/part1/ft_atoi.c | 0 {srcs => srcd}/part1/ft_bzero.c | 0 {srcs => srcd}/part1/ft_calloc.c | 0 {srcs => srcd}/part1/ft_isalnum.c | 0 {srcs => srcd}/part1/ft_isalpha.c | 0 {srcs => srcd}/part1/ft_isascii.c | 0 {srcs => srcd}/part1/ft_isdigit.c | 0 {srcs => srcd}/part1/ft_isprint.c | 0 {srcs => srcd}/part1/ft_memccpy.c | 0 {srcs => srcd}/part1/ft_memchr.c | 0 {srcs => srcd}/part1/ft_memcmp.c | 0 {srcs => srcd}/part1/ft_memcpy.c | 23 ++++- {srcs => srcd}/part1/ft_memmove.c | 0 {srcs => srcd}/part1/ft_memset.c | 0 {srcs => srcd}/part1/ft_strchr.c | 0 {srcs => srcd}/part1/ft_strdup.c | 0 {srcs => srcd}/part1/ft_strlcat.c | 0 {srcs => srcd}/part1/ft_strlcpy.c | 0 {srcs => srcd}/part1/ft_strlen.c | 0 {srcs => srcd}/part1/ft_strncmp.c | 0 {srcs => srcd}/part1/ft_strnstr.c | 0 {srcs => srcd}/part1/ft_strrchr.c | 0 {srcs => srcd}/part1/ft_tolower.c | 0 {srcs => srcd}/part1/ft_toupper.c | 0 {srcs => srcd}/part2/ft_itoa.c | 0 {srcs => srcd}/part2/ft_putchar_fd.c | 0 {srcs => srcd}/part2/ft_putendl_fd.c | 0 {srcs => srcd}/part2/ft_putnbr_fd.c | 0 {srcs => srcd}/part2/ft_putstr_fd.c | 0 {srcs => srcd}/part2/ft_split.c | 0 {srcs => srcd}/part2/ft_strjoin.c | 0 {srcs => srcd}/part2/ft_strmapi.c | 0 {srcs => srcd}/part2/ft_strtrim.c | 0 {srcs => srcd}/part2/ft_substr.c | 0 srcs/.DS_Store | Bin 6148 -> 0 bytes srcs/ft_any.c | 26 ++++++ srcs/ft_arraymap.c | 28 ++++++ srcs/ft_atoi.c | 39 ++++++++ srcs/ft_atoibase.c | 75 +++++++++++++++ srcs/ft_bzero.c | 27 ++++++ srcs/ft_calloc.c | 33 +++++++ srcs/ft_convertbase.c | 86 +++++++++++++++++ srcs/ft_foreach.c | 22 +++++ srcs/ft_isalnum.c | 18 ++++ srcs/ft_isalpha.c | 18 ++++ srcs/ft_isascii.c | 18 ++++ srcs/ft_isdigit.c | 18 ++++ srcs/ft_isprint.c | 18 ++++ srcs/ft_issort.c | 26 ++++++ srcs/ft_itoa.c | 55 +++++++++++ srcs/ft_lstadd_back.c | 91 ++++++++++++++++++ srcs/ft_lstadd_front.c | 94 +++++++++++++++++++ srcs/ft_lstclear.c | 102 ++++++++++++++++++++ srcs/ft_lstdelone.c | 96 +++++++++++++++++++ srcs/ft_lstiter.c | 83 +++++++++++++++++ srcs/ft_lstlast.c | 99 ++++++++++++++++++++ srcs/ft_lstmap.c | 119 ++++++++++++++++++++++++ srcs/ft_lstnew.c | 59 ++++++++++++ srcs/ft_lstsize.c | 86 +++++++++++++++++ srcs/ft_memalloc.c | 27 ++++++ srcs/ft_memccpy.c | 36 ++++++++ srcs/ft_memchr.c | 30 ++++++ srcs/ft_memcmp.c | 32 +++++++ srcs/ft_memcpy.c | 50 ++++++++++ srcs/ft_memdel.c | 26 ++++++ srcs/ft_memmove.c | 35 +++++++ srcs/ft_memset.c | 29 ++++++ srcs/ft_putchar.c | 18 ++++ srcs/ft_putchar_fd.c | 18 ++++ srcs/ft_putendl.c | 19 ++++ srcs/ft_putendl_fd.c | 23 +++++ srcs/ft_putnbr.c | 18 ++++ srcs/ft_putnbr_fd.c | 28 ++++++ srcs/ft_putnbrbase.c | 59 ++++++++++++ srcs/ft_putnbrendl.c | 18 ++++ srcs/ft_putnbrendl_fd.c | 29 ++++++ srcs/ft_putstr.c | 22 +++++ srcs/ft_putstr_fd.c | 23 +++++ srcs/ft_split.c | 123 +++++++++++++++++++++++++ srcs/ft_strcat.c | 32 +++++++ srcs/ft_strchr.c | 33 +++++++ srcs/ft_strclr.c | 23 +++++ srcs/ft_strcmp.c | 28 ++++++ srcs/ft_strcpy.c | 28 ++++++ srcs/ft_strdel.c | 26 ++++++ srcs/ft_strdup.c | 32 +++++++ srcs/ft_strequ.c | 24 +++++ srcs/ft_striter.c | 23 +++++ srcs/ft_striteri.c | 26 ++++++ srcs/ft_strjoin.c | 54 +++++++++++ srcs/ft_strjoinfree.c | 28 ++++++ srcs/ft_strlcat.c | 108 ++++++++++++++++++++++ srcs/ft_strlcpy.c | 66 +++++++++++++ srcs/ft_strlen.c | 27 ++++++ srcs/ft_strmap.c | 32 +++++++ srcs/ft_strmapi.c | 72 +++++++++++++++ srcs/ft_strmultisplit.c | 83 +++++++++++++++++ srcs/ft_strncat.c | 32 +++++++ srcs/ft_strncmp.c | 32 +++++++ srcs/ft_strncpy.c | 30 ++++++ srcs/ft_strnequ.c | 25 +++++ srcs/ft_strnew.c | 27 ++++++ srcs/ft_strnstr.c | 42 +++++++++ srcs/ft_strrchr.c | 32 +++++++ srcs/ft_strstr.c | 42 +++++++++ srcs/ft_strtrim.c | 90 ++++++++++++++++++ srcs/ft_substr.c | 52 +++++++++++ srcs/ft_tolower.c | 20 ++++ srcs/ft_toupper.c | 20 ++++ srcs/part2/a.out | Bin 8640 -> 0 bytes 152 files changed, 3206 insertions(+), 5 deletions(-) delete mode 100644 .Makefile.swp delete mode 100644 .testresults.swp rename {srcs => srcd}/add/ft_any.c (100%) rename {srcs => srcd}/add/ft_arraymap.c (100%) rename {srcs => srcd}/add/ft_atoibase.c (100%) rename {srcs => srcd}/add/ft_convertbase.c (100%) rename {srcs => srcd}/add/ft_foreach.c (100%) rename {srcs => srcd}/add/ft_issort.c (100%) rename {srcs => srcd}/add/ft_memalloc.c (100%) rename {srcs => srcd}/add/ft_memdel.c (100%) rename {srcs => srcd}/add/ft_putchar.c (100%) rename {srcs => srcd}/add/ft_putendl.c (100%) rename {srcs => srcd}/add/ft_putnbr.c (100%) rename {srcs => srcd}/add/ft_putnbrbase.c (100%) rename {srcs => srcd}/add/ft_putnbrendl.c (100%) rename {srcs => srcd}/add/ft_putnbrendl_fd.c (100%) rename {srcs => srcd}/add/ft_putstr.c (100%) rename {srcs => srcd}/add/ft_strcat.c (100%) rename {srcs => srcd}/add/ft_strclr.c (100%) rename {srcs => srcd}/add/ft_strcmp.c (100%) rename {srcs => srcd}/add/ft_strcpy.c (100%) rename {srcs => srcd}/add/ft_strdel.c (100%) rename {srcs => srcd}/add/ft_strequ.c (100%) rename {srcs => srcd}/add/ft_striter.c (100%) rename {srcs => srcd}/add/ft_striteri.c (100%) rename {srcs => srcd}/add/ft_strjoinfree.c (100%) rename {srcs => srcd}/add/ft_strmap.c (100%) rename {srcs => srcd}/add/ft_strmultisplit.c (100%) rename {srcs => srcd}/add/ft_strncat.c (100%) rename {srcs => srcd}/add/ft_strncpy.c (100%) rename {srcs => srcd}/add/ft_strnequ.c (100%) rename {srcs => srcd}/add/ft_strnew.c (100%) rename {srcs => srcd}/add/ft_strstr.c (100%) rename {srcs => srcd}/bonus/ft_lstadd_back.c (100%) rename {srcs => srcd}/bonus/ft_lstadd_front.c (100%) rename {srcs => srcd}/bonus/ft_lstclear.c (100%) rename {srcs => srcd}/bonus/ft_lstdelone.c (100%) rename {srcs => srcd}/bonus/ft_lstiter.c (100%) rename {srcs => srcd}/bonus/ft_lstlast.c (100%) rename {srcs => srcd}/bonus/ft_lstmap.c (100%) rename {srcs => srcd}/bonus/ft_lstnew.c (100%) rename {srcs => srcd}/bonus/ft_lstsize.c (100%) rename {srcs => srcd}/part1/ft_atoi.c (100%) rename {srcs => srcd}/part1/ft_bzero.c (100%) rename {srcs => srcd}/part1/ft_calloc.c (100%) rename {srcs => srcd}/part1/ft_isalnum.c (100%) rename {srcs => srcd}/part1/ft_isalpha.c (100%) rename {srcs => srcd}/part1/ft_isascii.c (100%) rename {srcs => srcd}/part1/ft_isdigit.c (100%) rename {srcs => srcd}/part1/ft_isprint.c (100%) rename {srcs => srcd}/part1/ft_memccpy.c (100%) rename {srcs => srcd}/part1/ft_memchr.c (100%) rename {srcs => srcd}/part1/ft_memcmp.c (100%) rename {srcs => srcd}/part1/ft_memcpy.c (74%) rename {srcs => srcd}/part1/ft_memmove.c (100%) rename {srcs => srcd}/part1/ft_memset.c (100%) rename {srcs => srcd}/part1/ft_strchr.c (100%) rename {srcs => srcd}/part1/ft_strdup.c (100%) rename {srcs => srcd}/part1/ft_strlcat.c (100%) rename {srcs => srcd}/part1/ft_strlcpy.c (100%) rename {srcs => srcd}/part1/ft_strlen.c (100%) rename {srcs => srcd}/part1/ft_strncmp.c (100%) rename {srcs => srcd}/part1/ft_strnstr.c (100%) rename {srcs => srcd}/part1/ft_strrchr.c (100%) rename {srcs => srcd}/part1/ft_tolower.c (100%) rename {srcs => srcd}/part1/ft_toupper.c (100%) rename {srcs => srcd}/part2/ft_itoa.c (100%) rename {srcs => srcd}/part2/ft_putchar_fd.c (100%) rename {srcs => srcd}/part2/ft_putendl_fd.c (100%) rename {srcs => srcd}/part2/ft_putnbr_fd.c (100%) rename {srcs => srcd}/part2/ft_putstr_fd.c (100%) rename {srcs => srcd}/part2/ft_split.c (100%) rename {srcs => srcd}/part2/ft_strjoin.c (100%) rename {srcs => srcd}/part2/ft_strmapi.c (100%) rename {srcs => srcd}/part2/ft_strtrim.c (100%) rename {srcs => srcd}/part2/ft_substr.c (100%) delete mode 100644 srcs/.DS_Store create mode 100644 srcs/ft_any.c create mode 100644 srcs/ft_arraymap.c create mode 100644 srcs/ft_atoi.c create mode 100644 srcs/ft_atoibase.c create mode 100644 srcs/ft_bzero.c create mode 100644 srcs/ft_calloc.c create mode 100644 srcs/ft_convertbase.c create mode 100644 srcs/ft_foreach.c create mode 100644 srcs/ft_isalnum.c create mode 100644 srcs/ft_isalpha.c create mode 100644 srcs/ft_isascii.c create mode 100644 srcs/ft_isdigit.c create mode 100644 srcs/ft_isprint.c create mode 100644 srcs/ft_issort.c create mode 100644 srcs/ft_itoa.c create mode 100644 srcs/ft_lstadd_back.c create mode 100644 srcs/ft_lstadd_front.c create mode 100644 srcs/ft_lstclear.c create mode 100644 srcs/ft_lstdelone.c create mode 100644 srcs/ft_lstiter.c create mode 100644 srcs/ft_lstlast.c create mode 100644 srcs/ft_lstmap.c create mode 100644 srcs/ft_lstnew.c create mode 100644 srcs/ft_lstsize.c create mode 100644 srcs/ft_memalloc.c create mode 100644 srcs/ft_memccpy.c create mode 100644 srcs/ft_memchr.c create mode 100644 srcs/ft_memcmp.c create mode 100644 srcs/ft_memcpy.c create mode 100644 srcs/ft_memdel.c create mode 100644 srcs/ft_memmove.c create mode 100644 srcs/ft_memset.c create mode 100644 srcs/ft_putchar.c create mode 100644 srcs/ft_putchar_fd.c create mode 100644 srcs/ft_putendl.c create mode 100644 srcs/ft_putendl_fd.c create mode 100644 srcs/ft_putnbr.c create mode 100644 srcs/ft_putnbr_fd.c create mode 100644 srcs/ft_putnbrbase.c create mode 100644 srcs/ft_putnbrendl.c create mode 100644 srcs/ft_putnbrendl_fd.c create mode 100644 srcs/ft_putstr.c create mode 100644 srcs/ft_putstr_fd.c create mode 100644 srcs/ft_split.c create mode 100644 srcs/ft_strcat.c create mode 100644 srcs/ft_strchr.c create mode 100644 srcs/ft_strclr.c create mode 100644 srcs/ft_strcmp.c create mode 100644 srcs/ft_strcpy.c create mode 100644 srcs/ft_strdel.c create mode 100644 srcs/ft_strdup.c create mode 100644 srcs/ft_strequ.c create mode 100644 srcs/ft_striter.c create mode 100644 srcs/ft_striteri.c create mode 100644 srcs/ft_strjoin.c create mode 100644 srcs/ft_strjoinfree.c create mode 100644 srcs/ft_strlcat.c create mode 100644 srcs/ft_strlcpy.c create mode 100644 srcs/ft_strlen.c create mode 100644 srcs/ft_strmap.c create mode 100644 srcs/ft_strmapi.c create mode 100644 srcs/ft_strmultisplit.c create mode 100644 srcs/ft_strncat.c create mode 100644 srcs/ft_strncmp.c create mode 100644 srcs/ft_strncpy.c create mode 100644 srcs/ft_strnequ.c create mode 100644 srcs/ft_strnew.c create mode 100644 srcs/ft_strnstr.c create mode 100644 srcs/ft_strrchr.c create mode 100644 srcs/ft_strstr.c create mode 100644 srcs/ft_strtrim.c create mode 100644 srcs/ft_substr.c create mode 100644 srcs/ft_tolower.c create mode 100644 srcs/ft_toupper.c delete mode 100755 srcs/part2/a.out diff --git a/.Makefile.swp b/.Makefile.swp deleted file mode 100644 index 0cd9d81756e08f323e5178b8c5ddb24f0200eee0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 45056 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%0DXp826zpD7J4uaYD!zLk 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 diff --git a/srcs/add/ft_any.c b/srcd/add/ft_any.c similarity index 100% rename from srcs/add/ft_any.c rename to srcd/add/ft_any.c diff --git a/srcs/add/ft_arraymap.c b/srcd/add/ft_arraymap.c similarity index 100% rename from srcs/add/ft_arraymap.c rename to srcd/add/ft_arraymap.c diff --git a/srcs/add/ft_atoibase.c b/srcd/add/ft_atoibase.c similarity index 100% rename from srcs/add/ft_atoibase.c rename to srcd/add/ft_atoibase.c diff --git a/srcs/add/ft_convertbase.c b/srcd/add/ft_convertbase.c similarity index 100% rename from srcs/add/ft_convertbase.c rename to srcd/add/ft_convertbase.c diff --git a/srcs/add/ft_foreach.c b/srcd/add/ft_foreach.c similarity index 100% rename from srcs/add/ft_foreach.c rename to srcd/add/ft_foreach.c diff --git a/srcs/add/ft_issort.c b/srcd/add/ft_issort.c similarity index 100% rename from srcs/add/ft_issort.c rename to srcd/add/ft_issort.c diff --git a/srcs/add/ft_memalloc.c b/srcd/add/ft_memalloc.c similarity index 100% rename from srcs/add/ft_memalloc.c rename to srcd/add/ft_memalloc.c diff --git a/srcs/add/ft_memdel.c b/srcd/add/ft_memdel.c similarity index 100% rename from srcs/add/ft_memdel.c rename to srcd/add/ft_memdel.c diff --git a/srcs/add/ft_putchar.c b/srcd/add/ft_putchar.c similarity index 100% rename from srcs/add/ft_putchar.c rename to srcd/add/ft_putchar.c diff --git a/srcs/add/ft_putendl.c b/srcd/add/ft_putendl.c similarity index 100% rename from srcs/add/ft_putendl.c rename to srcd/add/ft_putendl.c diff --git a/srcs/add/ft_putnbr.c b/srcd/add/ft_putnbr.c similarity index 100% rename from srcs/add/ft_putnbr.c rename to srcd/add/ft_putnbr.c diff --git a/srcs/add/ft_putnbrbase.c b/srcd/add/ft_putnbrbase.c similarity index 100% rename from srcs/add/ft_putnbrbase.c rename to srcd/add/ft_putnbrbase.c diff --git a/srcs/add/ft_putnbrendl.c b/srcd/add/ft_putnbrendl.c similarity index 100% rename from srcs/add/ft_putnbrendl.c rename to srcd/add/ft_putnbrendl.c diff --git a/srcs/add/ft_putnbrendl_fd.c b/srcd/add/ft_putnbrendl_fd.c similarity index 100% rename from srcs/add/ft_putnbrendl_fd.c rename to srcd/add/ft_putnbrendl_fd.c diff --git a/srcs/add/ft_putstr.c b/srcd/add/ft_putstr.c similarity index 100% rename from srcs/add/ft_putstr.c rename to srcd/add/ft_putstr.c diff --git a/srcs/add/ft_strcat.c b/srcd/add/ft_strcat.c similarity index 100% rename from srcs/add/ft_strcat.c rename to srcd/add/ft_strcat.c diff --git a/srcs/add/ft_strclr.c b/srcd/add/ft_strclr.c similarity index 100% rename from srcs/add/ft_strclr.c rename to srcd/add/ft_strclr.c diff --git a/srcs/add/ft_strcmp.c b/srcd/add/ft_strcmp.c similarity index 100% rename from srcs/add/ft_strcmp.c rename to srcd/add/ft_strcmp.c diff --git a/srcs/add/ft_strcpy.c b/srcd/add/ft_strcpy.c similarity index 100% rename from srcs/add/ft_strcpy.c rename to srcd/add/ft_strcpy.c diff --git a/srcs/add/ft_strdel.c b/srcd/add/ft_strdel.c similarity index 100% rename from srcs/add/ft_strdel.c rename to srcd/add/ft_strdel.c diff --git a/srcs/add/ft_strequ.c b/srcd/add/ft_strequ.c similarity index 100% rename from srcs/add/ft_strequ.c rename to srcd/add/ft_strequ.c diff --git a/srcs/add/ft_striter.c b/srcd/add/ft_striter.c similarity index 100% rename from srcs/add/ft_striter.c rename to srcd/add/ft_striter.c diff --git a/srcs/add/ft_striteri.c b/srcd/add/ft_striteri.c similarity index 100% rename from srcs/add/ft_striteri.c rename to srcd/add/ft_striteri.c diff --git a/srcs/add/ft_strjoinfree.c b/srcd/add/ft_strjoinfree.c similarity index 100% rename from srcs/add/ft_strjoinfree.c rename to srcd/add/ft_strjoinfree.c diff --git a/srcs/add/ft_strmap.c b/srcd/add/ft_strmap.c similarity index 100% rename from srcs/add/ft_strmap.c rename to srcd/add/ft_strmap.c diff --git a/srcs/add/ft_strmultisplit.c b/srcd/add/ft_strmultisplit.c similarity index 100% rename from srcs/add/ft_strmultisplit.c rename to srcd/add/ft_strmultisplit.c diff --git a/srcs/add/ft_strncat.c b/srcd/add/ft_strncat.c similarity index 100% rename from srcs/add/ft_strncat.c rename to srcd/add/ft_strncat.c diff --git a/srcs/add/ft_strncpy.c b/srcd/add/ft_strncpy.c similarity index 100% rename from srcs/add/ft_strncpy.c rename to srcd/add/ft_strncpy.c diff --git a/srcs/add/ft_strnequ.c b/srcd/add/ft_strnequ.c similarity index 100% rename from srcs/add/ft_strnequ.c rename to srcd/add/ft_strnequ.c diff --git a/srcs/add/ft_strnew.c b/srcd/add/ft_strnew.c similarity index 100% rename from srcs/add/ft_strnew.c rename to srcd/add/ft_strnew.c diff --git a/srcs/add/ft_strstr.c b/srcd/add/ft_strstr.c similarity index 100% rename from srcs/add/ft_strstr.c rename to srcd/add/ft_strstr.c diff --git a/srcs/bonus/ft_lstadd_back.c b/srcd/bonus/ft_lstadd_back.c similarity index 100% rename from srcs/bonus/ft_lstadd_back.c rename to srcd/bonus/ft_lstadd_back.c diff --git a/srcs/bonus/ft_lstadd_front.c b/srcd/bonus/ft_lstadd_front.c similarity index 100% rename from srcs/bonus/ft_lstadd_front.c rename to srcd/bonus/ft_lstadd_front.c diff --git a/srcs/bonus/ft_lstclear.c b/srcd/bonus/ft_lstclear.c similarity index 100% rename from srcs/bonus/ft_lstclear.c rename to srcd/bonus/ft_lstclear.c diff --git a/srcs/bonus/ft_lstdelone.c b/srcd/bonus/ft_lstdelone.c similarity index 100% rename from srcs/bonus/ft_lstdelone.c rename to srcd/bonus/ft_lstdelone.c diff --git a/srcs/bonus/ft_lstiter.c b/srcd/bonus/ft_lstiter.c similarity index 100% rename from srcs/bonus/ft_lstiter.c rename to srcd/bonus/ft_lstiter.c diff --git a/srcs/bonus/ft_lstlast.c b/srcd/bonus/ft_lstlast.c similarity index 100% rename from srcs/bonus/ft_lstlast.c rename to srcd/bonus/ft_lstlast.c diff --git a/srcs/bonus/ft_lstmap.c b/srcd/bonus/ft_lstmap.c similarity index 100% rename from srcs/bonus/ft_lstmap.c rename to srcd/bonus/ft_lstmap.c diff --git a/srcs/bonus/ft_lstnew.c b/srcd/bonus/ft_lstnew.c similarity index 100% rename from srcs/bonus/ft_lstnew.c rename to srcd/bonus/ft_lstnew.c diff --git a/srcs/bonus/ft_lstsize.c b/srcd/bonus/ft_lstsize.c similarity index 100% rename from srcs/bonus/ft_lstsize.c rename to srcd/bonus/ft_lstsize.c diff --git a/srcs/part1/ft_atoi.c b/srcd/part1/ft_atoi.c similarity index 100% rename from srcs/part1/ft_atoi.c rename to srcd/part1/ft_atoi.c diff --git a/srcs/part1/ft_bzero.c b/srcd/part1/ft_bzero.c similarity index 100% rename from srcs/part1/ft_bzero.c rename to srcd/part1/ft_bzero.c diff --git a/srcs/part1/ft_calloc.c b/srcd/part1/ft_calloc.c similarity index 100% rename from srcs/part1/ft_calloc.c rename to srcd/part1/ft_calloc.c diff --git a/srcs/part1/ft_isalnum.c b/srcd/part1/ft_isalnum.c similarity index 100% rename from srcs/part1/ft_isalnum.c rename to srcd/part1/ft_isalnum.c diff --git a/srcs/part1/ft_isalpha.c b/srcd/part1/ft_isalpha.c similarity index 100% rename from srcs/part1/ft_isalpha.c rename to srcd/part1/ft_isalpha.c diff --git a/srcs/part1/ft_isascii.c b/srcd/part1/ft_isascii.c similarity index 100% rename from srcs/part1/ft_isascii.c rename to srcd/part1/ft_isascii.c diff --git a/srcs/part1/ft_isdigit.c b/srcd/part1/ft_isdigit.c similarity index 100% rename from srcs/part1/ft_isdigit.c rename to srcd/part1/ft_isdigit.c diff --git a/srcs/part1/ft_isprint.c b/srcd/part1/ft_isprint.c similarity index 100% rename from srcs/part1/ft_isprint.c rename to srcd/part1/ft_isprint.c diff --git a/srcs/part1/ft_memccpy.c b/srcd/part1/ft_memccpy.c similarity index 100% rename from srcs/part1/ft_memccpy.c rename to srcd/part1/ft_memccpy.c diff --git a/srcs/part1/ft_memchr.c b/srcd/part1/ft_memchr.c similarity index 100% rename from srcs/part1/ft_memchr.c rename to srcd/part1/ft_memchr.c diff --git a/srcs/part1/ft_memcmp.c b/srcd/part1/ft_memcmp.c similarity index 100% rename from srcs/part1/ft_memcmp.c rename to srcd/part1/ft_memcmp.c diff --git a/srcs/part1/ft_memcpy.c b/srcd/part1/ft_memcpy.c similarity index 74% rename from srcs/part1/ft_memcpy.c rename to srcd/part1/ft_memcpy.c index 489857d..6cee84f 100644 --- a/srcs/part1/ft_memcpy.c +++ b/srcd/part1/ft_memcpy.c @@ -6,7 +6,7 @@ /* By: hulamy +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2019/11/25 13:56:16 by hulamy #+# #+# */ -/* Updated: 2019/11/25 13:56:17 by hulamy ### ########.fr */ +/* Updated: 2019/11/28 13:47:43 by hulamy ### ########.fr */ /* */ /* ************************************************************************** */ @@ -14,18 +14,31 @@ ** copy n characters from src to dst and return dst */ +/* +** #include +** +** void *ft_memcpy(void *dst, const void *src, size_t n); +** +** int main(int ac, char **av) +** { +** if (ac == 4) +** printf("%s\n", ft_memcpy(av[1], av[2], atoi(av[3]))); +** return (0); +** } +*/ + #include "libft.h" void *ft_memcpy(void *dst, const void *src, size_t n) { - size_t i; char *ptr; char *ptr2; ptr = (char *)dst; ptr2 = (char *)src; - i = -1; - while (++i < n) - ptr[i] = ptr2[i]; + if (dst == src) + return (dst); + while (n--) + ptr[n] = ptr2[n]; return (dst); } diff --git a/srcs/part1/ft_memmove.c b/srcd/part1/ft_memmove.c similarity index 100% rename from srcs/part1/ft_memmove.c rename to srcd/part1/ft_memmove.c diff --git a/srcs/part1/ft_memset.c b/srcd/part1/ft_memset.c similarity index 100% rename from srcs/part1/ft_memset.c rename to srcd/part1/ft_memset.c diff --git a/srcs/part1/ft_strchr.c b/srcd/part1/ft_strchr.c similarity index 100% rename from srcs/part1/ft_strchr.c rename to srcd/part1/ft_strchr.c diff --git a/srcs/part1/ft_strdup.c b/srcd/part1/ft_strdup.c similarity index 100% rename from srcs/part1/ft_strdup.c rename to srcd/part1/ft_strdup.c diff --git a/srcs/part1/ft_strlcat.c b/srcd/part1/ft_strlcat.c similarity index 100% rename from srcs/part1/ft_strlcat.c rename to srcd/part1/ft_strlcat.c diff --git a/srcs/part1/ft_strlcpy.c b/srcd/part1/ft_strlcpy.c similarity index 100% rename from srcs/part1/ft_strlcpy.c rename to srcd/part1/ft_strlcpy.c diff --git a/srcs/part1/ft_strlen.c b/srcd/part1/ft_strlen.c similarity index 100% rename from srcs/part1/ft_strlen.c rename to srcd/part1/ft_strlen.c diff --git a/srcs/part1/ft_strncmp.c b/srcd/part1/ft_strncmp.c similarity index 100% rename from srcs/part1/ft_strncmp.c rename to srcd/part1/ft_strncmp.c diff --git a/srcs/part1/ft_strnstr.c b/srcd/part1/ft_strnstr.c similarity index 100% rename from srcs/part1/ft_strnstr.c rename to srcd/part1/ft_strnstr.c diff --git a/srcs/part1/ft_strrchr.c b/srcd/part1/ft_strrchr.c similarity index 100% rename from srcs/part1/ft_strrchr.c rename to srcd/part1/ft_strrchr.c diff --git a/srcs/part1/ft_tolower.c b/srcd/part1/ft_tolower.c similarity index 100% rename from srcs/part1/ft_tolower.c rename to srcd/part1/ft_tolower.c diff --git a/srcs/part1/ft_toupper.c b/srcd/part1/ft_toupper.c similarity index 100% rename from srcs/part1/ft_toupper.c rename to srcd/part1/ft_toupper.c diff --git a/srcs/part2/ft_itoa.c b/srcd/part2/ft_itoa.c similarity index 100% rename from srcs/part2/ft_itoa.c rename to srcd/part2/ft_itoa.c diff --git a/srcs/part2/ft_putchar_fd.c b/srcd/part2/ft_putchar_fd.c similarity index 100% rename from srcs/part2/ft_putchar_fd.c rename to srcd/part2/ft_putchar_fd.c diff --git a/srcs/part2/ft_putendl_fd.c b/srcd/part2/ft_putendl_fd.c similarity index 100% rename from srcs/part2/ft_putendl_fd.c rename to srcd/part2/ft_putendl_fd.c diff --git a/srcs/part2/ft_putnbr_fd.c b/srcd/part2/ft_putnbr_fd.c similarity index 100% rename from srcs/part2/ft_putnbr_fd.c rename to srcd/part2/ft_putnbr_fd.c diff --git a/srcs/part2/ft_putstr_fd.c b/srcd/part2/ft_putstr_fd.c similarity index 100% rename from srcs/part2/ft_putstr_fd.c rename to srcd/part2/ft_putstr_fd.c diff --git a/srcs/part2/ft_split.c b/srcd/part2/ft_split.c similarity index 100% rename from srcs/part2/ft_split.c rename to srcd/part2/ft_split.c diff --git a/srcs/part2/ft_strjoin.c b/srcd/part2/ft_strjoin.c similarity index 100% rename from srcs/part2/ft_strjoin.c rename to srcd/part2/ft_strjoin.c diff --git a/srcs/part2/ft_strmapi.c b/srcd/part2/ft_strmapi.c similarity index 100% rename from srcs/part2/ft_strmapi.c rename to srcd/part2/ft_strmapi.c diff --git a/srcs/part2/ft_strtrim.c b/srcd/part2/ft_strtrim.c similarity index 100% rename from srcs/part2/ft_strtrim.c rename to srcd/part2/ft_strtrim.c diff --git a/srcs/part2/ft_substr.c b/srcd/part2/ft_substr.c similarity index 100% rename from srcs/part2/ft_substr.c rename to srcd/part2/ft_substr.c diff --git a/srcs/.DS_Store b/srcs/.DS_Store deleted file mode 100644 index 36539299592336eff491eff337f1f5f16e362c3d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6148 zcmeHKI|>3Z5S{S@f{mqRuHX%V=n3`$B7%*qplH37=kjR2`83O7r-kwcCNG)HOUNsB zc0@$ix5G+gAtE!lp*(CDn(dnpY?KiN!g0p+-dx(#xjhbY-vx|2mA#y$m0OQ*J2Wal z1*iZOpaN9j(+XsToy|XeFwdg`RN&_ouHg$K#o*^3iK5i$8urye+z%p z|My8;Q2{FOR|@E4(`?pwQr6bNi80h5~3oFM#>1-`Ao3mSqH-~a#s diff --git a/srcs/ft_any.c b/srcs/ft_any.c new file mode 100644 index 0000000..349e3a9 --- /dev/null +++ b/srcs/ft_any.c @@ -0,0 +1,26 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_any.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/16 15:14:49 by hulamy #+# #+# */ +/* Updated: 2018/11/16 15:14:53 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_any(char **tab, int (*f)(char*)) +{ + int i; + + i = -1; + if (!tab) + return (0); + while (tab[++i]) + if (f(tab[i]) == 1) + return (1); + return (0); +} diff --git a/srcs/ft_arraymap.c b/srcs/ft_arraymap.c new file mode 100644 index 0000000..267510a --- /dev/null +++ b/srcs/ft_arraymap.c @@ -0,0 +1,28 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_arraymap.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/16 15:17:24 by hulamy #+# #+# */ +/* Updated: 2018/11/16 15:17:27 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int *ft_arraymap(int *tab, int length, int (*f)(int)) +{ + int i; + int *newtab; + + i = -1; + if (!tab) + return (NULL); + if (!(newtab = (int*)malloc(sizeof(*newtab) * (length + 1)))) + return (NULL); + while (++i < length) + newtab[i] = (*f)(tab[i]); + return (newtab); +} diff --git a/srcs/ft_atoi.c b/srcs/ft_atoi.c new file mode 100644 index 0000000..74da199 --- /dev/null +++ b/srcs/ft_atoi.c @@ -0,0 +1,39 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_atoi.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:54:29 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:54:35 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_atoi(const char *str) +{ + long long nbr; + int i; + int n; + + i = 0; + n = 1; + nbr = 0; + while ((str[i] == 32) || (str[i] > 8 && str[i] < 14)) + i++; + if (str[i] == '-') + n = -1; + if (str[i] == '+' || str[i] == '-') + i++; + while (str[i] >= '0' && str[i] <= '9') + { + if ((nbr >= 922337203685477580 + && ((str[i] > 8 && n < 0) || (str[i] > 7 && n > 0)))) + return ((n > 0) ? -1 : 0); + else + nbr = nbr * 10 + (str[i++] - '0'); + } + return (nbr * n); +} diff --git a/srcs/ft_atoibase.c b/srcs/ft_atoibase.c new file mode 100644 index 0000000..fdb92d1 --- /dev/null +++ b/srcs/ft_atoibase.c @@ -0,0 +1,75 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_atoibase.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/16 15:15:31 by hulamy #+# #+# */ +/* Updated: 2018/11/16 15:22:34 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +static int is_valid_base(char *base, int i, int j) +{ + while (base[i]) + { + j = i + 1; + while (base[j]) + { + if (base[i] == base[j]) + return (0); + j++; + } + if (base[i] == '-' || base[i] == '+') + return (0); + i++; + } + if (i >= 2) + return (1); + return (0); +} + +static int skip(int i, char *str, int *n) +{ + while ((str[i] == 32) || (str[i] > 8 && str[i] < 14)) + i++; + if (str[i] == '+' || str[i] == '-') + { + if (str[i] == '-') + *n = -1; + i++; + } + return (i); +} + +int ft_atoibase(char *str, char *base) +{ + int i; + int j; + int length; + int res; + int n; + + length = 0; + res = 0; + n = 1; + if (!is_valid_base(base, 0, 0)) + return (0); + while (base[length]) + length++; + i = skip(0, str, &n); + while (str[i] && str[i] > 32 && str[i] != '-' && str[i] != '+') + { + j = 0; + while (str[i] != base[j] && base[j]) + j++; + if (base[j] == '\0') + return (0); + res = (res * length) + j; + i++; + } + return (res * n); +} diff --git a/srcs/ft_bzero.c b/srcs/ft_bzero.c new file mode 100644 index 0000000..f66336a --- /dev/null +++ b/srcs/ft_bzero.c @@ -0,0 +1,27 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_bzero.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:54:43 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:54:44 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_bzero(void *s, size_t n) +{ + size_t i; + unsigned char *ptr; + + if (n) + { + ptr = (unsigned char *)s; + i = 0; + while (i < n) + ptr[i++] = '\0'; + } +} diff --git a/srcs/ft_calloc.c b/srcs/ft_calloc.c new file mode 100644 index 0000000..611ce62 --- /dev/null +++ b/srcs/ft_calloc.c @@ -0,0 +1,33 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_calloc.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:54:53 by hulamy #+# #+# */ +/* Updated: 2019/11/25 14:28:35 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** exemple allocation for 5 integers with malloc then calloc : +** a = (int *)malloc(5 * sizeof(int)); //5*4bytes = 20 bytes +** free(a); +** a = (int *)calloc(5, sizeof(int)); +** +** allocate count * size byte of memory and +** return a pointer to the allocated memory +*/ + +#include "libft.h" + +void *ft_calloc(size_t count, size_t size) +{ + void *tmp; + + if (!count || !size || !(tmp = malloc(count * size))) + return (NULL); + ft_bzero(tmp, count * size); + return (tmp); +} diff --git a/srcs/ft_convertbase.c b/srcs/ft_convertbase.c new file mode 100644 index 0000000..7fe9bad --- /dev/null +++ b/srcs/ft_convertbase.c @@ -0,0 +1,86 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_convertbase.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/16 15:15:55 by hulamy #+# #+# */ +/* Updated: 2019/04/17 17:09:35 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +static int ft_malloc_size(int decimal, int length, int i) +{ + if (decimal <= 0) + i++; + while (decimal) + { + decimal /= length; + i++; + } + return (i); +} + +static char *ft_decimal_to_base(int decimal, char *base, char *res, int size) +{ + long nb; + int i; + + nb = decimal; + i = 0; + while (base[i]) + i++; + if (nb < 0) + nb = -nb; + while (--size >= 0) + { + res[size] = base[nb % i]; + nb /= i; + } + return (res); +} + +static int ft_base_to_decimal(char *nbr, char *base, int length, int i) +{ + long decimal; + int j; + + decimal = 0; + if (nbr[i] == '-') + i++; + while (nbr[i]) + { + j = 0; + while (nbr[i] != base[j] && base[j]) + j++; + decimal = (decimal * length) + j; + i++; + } + if (nbr[0] == '-') + decimal = -decimal; + return (decimal); +} + +char *ft_convertbase(char *nbr, char *base_from, char *base_to) +{ + int length; + int size; + int decimal; + char *res; + + res = 0; + length = 0; + while (base_from[length]) + length++; + decimal = ft_base_to_decimal(nbr, base_from, length, 0); + length = 0; + while (base_to[length]) + length++; + size = ft_malloc_size(decimal, length, 0); + res = (char *)malloc(sizeof(char) * (size + 1)); + res[size] = '\0'; + return (ft_decimal_to_base(decimal, base_to, res, size)); +} diff --git a/srcs/ft_foreach.c b/srcs/ft_foreach.c new file mode 100644 index 0000000..aaf7649 --- /dev/null +++ b/srcs/ft_foreach.c @@ -0,0 +1,22 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_foreach.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/16 15:16:10 by hulamy #+# #+# */ +/* Updated: 2018/11/16 15:16:11 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_foreach(int *tab, int length, void (*f)(int)) +{ + int i; + + i = 0; + while (i < length && tab && tab[i]) + (*f)(tab[i++]); +} diff --git a/srcs/ft_isalnum.c b/srcs/ft_isalnum.c new file mode 100644 index 0000000..dc1bb03 --- /dev/null +++ b/srcs/ft_isalnum.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_isalnum.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:55:05 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:55:06 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_isalnum(int c) +{ + return (ft_isalpha(c) || ft_isdigit(c)); +} diff --git a/srcs/ft_isalpha.c b/srcs/ft_isalpha.c new file mode 100644 index 0000000..e0ec883 --- /dev/null +++ b/srcs/ft_isalpha.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_isalpha.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:55:15 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:55:17 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_isalpha(int c) +{ + return ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')); +} diff --git a/srcs/ft_isascii.c b/srcs/ft_isascii.c new file mode 100644 index 0000000..f201880 --- /dev/null +++ b/srcs/ft_isascii.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_isascii.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:55:24 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:55:25 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_isascii(int c) +{ + return (c >= 0 && c <= 127); +} diff --git a/srcs/ft_isdigit.c b/srcs/ft_isdigit.c new file mode 100644 index 0000000..69e0809 --- /dev/null +++ b/srcs/ft_isdigit.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_isdigit.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:55:32 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:55:33 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_isdigit(int c) +{ + return (c >= '0' && c <= '9'); +} diff --git a/srcs/ft_isprint.c b/srcs/ft_isprint.c new file mode 100644 index 0000000..21395ab --- /dev/null +++ b/srcs/ft_isprint.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_isprint.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:55:43 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:55:44 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_isprint(int c) +{ + return (c >= 32 && c < 127); +} diff --git a/srcs/ft_issort.c b/srcs/ft_issort.c new file mode 100644 index 0000000..842195b --- /dev/null +++ b/srcs/ft_issort.c @@ -0,0 +1,26 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_issort.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/16 15:18:14 by hulamy #+# #+# */ +/* Updated: 2018/11/16 15:18:15 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_issort(int *tab, int length, int (*f)(int, int)) +{ + int i; + + i = -1; + if (!tab) + return (0); + while (++i < length - 1) + if (f(tab[i], tab[i + 1]) > 0) + return (0); + return (1); +} diff --git a/srcs/ft_itoa.c b/srcs/ft_itoa.c new file mode 100644 index 0000000..af0406b --- /dev/null +++ b/srcs/ft_itoa.c @@ -0,0 +1,55 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_itoa.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:59:01 by hulamy #+# #+# */ +/* Updated: 2019/11/25 14:21:01 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** take an integer and give a string +*/ + +/* +** #include +** +** char *ft_itoa(int n) +** +** int main(int ac, char **av) +** { +** if (ac == 2) +** { +** printf("%s\n",ft_itoa(atoi(av[1]))); +** } +** return 0; +** } +*/ + +#include "libft.h" + +char *ft_itoa(int n) +{ + char *str; + int len; + long int nbis; + + len = (n < 0) ? 2 : 1; + nbis = n; + while (nbis /= 10) + len++; + nbis = n; + nbis *= (nbis < 0) ? -1 : 1; + if (!(str = (char *)malloc(sizeof(char) * (len + 1)))) + return (NULL); + str[len] = '\0'; + str[--len] = nbis % 10 + '0'; + while (nbis /= 10) + str[--len] = nbis % 10 + '0'; + if (n < 0) + str[0] = '-'; + return (str); +} diff --git a/srcs/ft_lstadd_back.c b/srcs/ft_lstadd_back.c new file mode 100644 index 0000000..37084d1 --- /dev/null +++ b/srcs/ft_lstadd_back.c @@ -0,0 +1,91 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstadd_back.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 14:11:53 by hulamy #+# #+# */ +/* Updated: 2019/11/25 14:36:12 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** add an element to the end of a list +** or first if list has no element so far +*/ + +/* +** #include +** +** typedef struct s_list +** { +** void *content; +** struct s_list *next; +** } t_list; +** +** t_list *ft_lstnew(void *content) +** { +** t_list *lst; +** +** if (!(lst = (t_list *)malloc(sizeof(*lst)))) +** return (NULL); +** if (!content) +** lst->content = NULL; +** else +** lst->content = content; +** lst->next = NULL; +** return (lst); +** } +** +** void ft_lstadd_back(t_list **alst, t_list *new); +** +** int main(void) +** { +** char tresor; +** char matos; +** char friends; +** t_list *toto; +** t_list *tmp; +** +** tresor = 'a'; +** matos = 'b'; +** friends = 'c'; +** toto = ft_lstnew(&tresor); +** printf("toto->data :%c\n",*(char*)(toto->content)); +** tmp = ft_lstnew(&matos); +** ft_lstadd_back(&toto, tmp); +** printf("----------------------\n"); +** printf("toto->data :%c\n",*(char*)(toto->content)); +** printf("toto->nxt->data :%c\n",*(char*)(toto->next->content)); +** tmp = ft_lstnew(&friends); +** ft_lstadd_back(&toto, tmp); +** printf("----------------------\n"); +** printf("toto->data :%c\n",*(char*)(toto->content)); +** printf("toto->nxt->data :%c\n",*(char*)(toto->next->content)); +** printf("toto->nxt->nxt->data:%c\n",*(char*)(toto->next->next->content)); +** printf("toto->nxt->nxt->nxt :%s\n",(char*)(toto->next->next->next)); +** return (0); +** } +*/ + +#include "libft.h" + +void ft_lstadd_back(t_list **alst, t_list *new) +{ + t_list *tmp; + + if (alst) + { + tmp = *alst; + if (!tmp) + *alst = new; + else + { + while (tmp->next) + tmp = tmp->next; + tmp->next = new; + } + new->next = NULL; + } +} diff --git a/srcs/ft_lstadd_front.c b/srcs/ft_lstadd_front.c new file mode 100644 index 0000000..3f90569 --- /dev/null +++ b/srcs/ft_lstadd_front.c @@ -0,0 +1,94 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstadd_front.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 14:12:02 by hulamy #+# #+# */ +/* Updated: 2019/11/25 14:36:54 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** add an element to the begining of a list +*/ + +/* +** #include +** +** typedef struct s_list +** { +** void *content; +** struct s_list *next; +** } t_list; +** +** void *ft_memcpy(void *dst, const void *src, size_t n) +** { +** size_t i; +** char *ptr; +** char *ptr2; +** +** ptr = (char *)dst; +** ptr2 = (char *)src; +** i = -1; +** while (++i < n) +** ptr[i] = ptr2[i]; +** return (dst); +** } +** +** t_list *ft_lstnew(void *content) +** { +** t_list *lst; +** +** if (!(lst = (t_list *)malloc(sizeof(*lst)))) +** return (NULL); +** if (!content) +** lst->content = NULL; +** else +** { +** if (!(lst->content = malloc(sizeof(content)))) +** return (NULL); +** ft_memcpy(lst->content, content, sizeof(content)); +** } +** lst->next = NULL; +** return (lst); +** } +** +** void ft_lstadd_front(t_list **alst, t_list *new); +** +** int main(void) +** { +** char tresor; +** char matos; +** char friends; +** t_list *toto; +** t_list *tmp; +** +** tresor = 'a'; +** matos = 'b'; +** friends = 'c'; +** toto = ft_lstnew(&tresor); +** printf("toto->data :%c\n",*(char*)(toto->content)); +** tmp = ft_lstnew(&matos); +** ft_lstadd_front(&toto, tmp); +** printf("----------------------\n"); +** printf("toto->data :%c\n",*(char*)(toto->content)); +** printf("toto->nxt->data :%c\n",*(char*)(toto->next->content)); +** tmp = ft_lstnew(&friends); +** ft_lstadd_front(&toto, tmp); +** printf("----------------------\n"); +** printf("toto->data :%c\n",*(char*)(toto->content)); +** printf("toto->nxt->data :%c\n",*(char*)(toto->next->content)); +** printf("toto->nxt->nxt->dqta:%c\n",*(char*)(toto->next->next->content)); +** return (0); +** } +*/ + +#include "libft.h" + +void ft_lstadd_front(t_list **alst, t_list *new) +{ + new->next = *alst; + *alst = new; +} diff --git a/srcs/ft_lstclear.c b/srcs/ft_lstclear.c new file mode 100644 index 0000000..b66cc39 --- /dev/null +++ b/srcs/ft_lstclear.c @@ -0,0 +1,102 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstclear.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 14:13:30 by hulamy #+# #+# */ +/* Updated: 2019/11/25 14:31:30 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** delete and free an element of the list and all the followings +*/ + +/* +** #include +** +** typedef struct s_list +** { +** void *content; +** struct s_list *next; +** } t_list; +** +** t_list *ft_lstnew(void *content) +** { +** t_list *lst; +** +** if (!(lst = (t_list *)malloc(sizeof(*lst)))) +** return (NULL); +** if (!content) +** lst->content = NULL; +** else +** lst->content = content; +** lst->next = NULL; +** return (lst); +** } +** +** void ft_lstadd_back(t_list **alst, t_list *new) +** { +** t_list *tmp; +** +** if (alst) +** { +** tmp = *alst; +** if (!tmp) +** *alst = new; +** else +** { +** while (tmp->next) +** tmp = tmp->next; +** tmp->next = new; +** } +** new->next = NULL; +** } +** } +** +** void ft_delete(void *element) +** { +** *(char*)element = '\0'; +** } +** +** void ft_lstdelone(t_list *lst, void (*del)(void *)) +** { +** del(lst->content); +** free(lst); +** lst = NULL; +** } +** +** void ft_lstclear(t_list **lst, void (*del)(void *)); +** +** int main(void) +** { +** t_list *toto; +** void (ft_delete)(void*); +** +** printf("sizeof(t_list)%lu\n",sizeof(t_list)); +** toto = ft_lstnew("a"); +** toto->next = ft_lstnew("b"); +** toto->next->next = ft_lstnew("c"); +** printf("toto->data :%c\n",*(char*)(toto->content)); +** printf("toto->nxt->data :%c\n",*(char*)(toto->next->content)); +** printf("toto->nxt->nxt->data:%c\n",*(char*)(toto->next->next->content)); +** printf("toto->nxt->nxt->nxt :%s\n",(char*)(toto->next->next->next)); +** ft_lstclear(&(toto->next), ft_delete); +** printf("----------------------\n"); +** printf("toto->data :%c\n",*(char*)(toto->content)); +** printf("toto->nxt->data :%c\n",*(char*)(toto->next->content)); +** printf("toto->nxt->nxt :%s\n",(char*)(toto->next->next)); +** return (0); +** } +*/ + +#include "libft.h" + +void ft_lstclear(t_list **lst, void (*del)(void *)) +{ + if ((*lst)->next) + ft_lstclear(&(*lst)->next, del); + ft_lstdelone(*lst, del); +} diff --git a/srcs/ft_lstdelone.c b/srcs/ft_lstdelone.c new file mode 100644 index 0000000..3ff3259 --- /dev/null +++ b/srcs/ft_lstdelone.c @@ -0,0 +1,96 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstdelone.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 14:14:03 by hulamy #+# #+# */ +/* Updated: 2019/11/25 14:35:53 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** free an element and delete its content with del +** next is not free +*/ + +/* +** #include +** +** typedef struct s_list +** { +** void *content; +** struct s_list *next; +** } t_list; +** +** t_list *ft_lstnew(void *content) +** { +** t_list *lst; +** +** if (!(lst = (t_list *)malloc(sizeof(*lst)))) +** return (NULL); +** if (!content) +** lst->content = NULL; +** else +** lst->content = content; +** lst->next = NULL; +** return (lst); +** } +** +** void ft_lstadd_back(t_list **alst, t_list *new) +** { +** t_list *tmp; +** +** if (alst) +** { +** tmp = *alst; +** if (!tmp) +** *alst = new; +** else +** { +** while (tmp->next) +** tmp = tmp->next; +** tmp->next = new; +** } +** new->next = NULL; +** } +** } +** +** void ft_delete(void *element) +** { +** *(char*)element = '\0'; +** } +** +** void ft_lstdelone(t_list *lst, void (*del)(void *)); +** +** int main(void) +** { +** t_list *toto; +** void (ft_delete)(void*); +** +** toto = ft_lstnew("a"); +** toto->next = ft_lstnew("b"); +** toto->next->next = ft_lstnew("c"); +** printf("toto->data :%c\n",*(char*)(toto->content)); +** printf("toto->nxt->data :%c\n",*(char*)(toto->next->content)); +** printf("toto->nxt->nxt->data:%c\n",*(char*)(toto->next->next->content)); +** printf("toto->nxt->nxt->nxt :%s\n",(char*)(toto->next->next->next)); +** ft_lstdelone(toto->next, ft_delete); +** printf("----------------------\n"); +** printf("toto->data :%c\n",*(char*)(toto->content)); +** printf("toto->nxt->data :%c\n",*(char*)(toto->next->content)); +** printf("toto->nxt->nxt->data:%c\n",*(char*)(toto->next->next->content)); +** printf("toto->nxt->nxt->nxt :%s\n",(char*)(toto->next->next->next)); +** return (0); +** } +*/ + +#include "libft.h" + +void ft_lstdelone(t_list *lst, void (*del)(void *)) +{ + del(lst->content); + free(lst); + lst = NULL; +} diff --git a/srcs/ft_lstiter.c b/srcs/ft_lstiter.c new file mode 100644 index 0000000..52ab6ad --- /dev/null +++ b/srcs/ft_lstiter.c @@ -0,0 +1,83 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstiter.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 14:14:11 by hulamy #+# #+# */ +/* Updated: 2019/11/25 14:34:59 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** go through all elements of the list and apply the function f to each of them +*/ + +/* +** #include +** +** typedef struct s_list +** { +** void *content; +** struct s_list *next; +** } t_list; +** +** t_list *ft_lstnew(void *content) +** { +** t_list *lst; +** +** if (!(lst = (t_list *)malloc(sizeof(*lst)))) +** return (NULL); +** if (!content) +** lst->content = NULL; +** else +** lst->content = content; +** lst->next = NULL; +** return (lst); +** } +** +** void ft_lstiter(t_list *lst, void (*f)(void*)); +** +** void to_uppercase(void *element) +** { +** // *(char*)(((t_list*)element)->content) -= 32; +** // or : +** t_list *tmp; +** +** tmp = (t_list*)element; +** *(char*)(tmp->content) -= 32; +** } +** +** int main(void) +** { +** t_list *toto; +** void to_uppercase(void*); +** +** toto = ft_lstnew("a"); +** toto->next = ft_lstnew("b"); +** toto->next->next = ft_lstnew("c"); +** printf("toto->data :%c\n",*(char*)(toto->content)); +** printf("toto->nxt->data :%c\n",*(char*)(toto->next->content)); +** printf("toto->nxt->nxt->data:%c\n",*(char*)(toto->next->next->content)); +** printf("toto->nxt->nxt->nxt :%s\n",(char*)(toto->next->next->next)); +** printf("---------------------------\n"); +** ft_lstiter(toto, to_uppercase); +** printf("toto->data :%c\n",*(char*)(toto->content)); +** printf("toto->nxt->data :%c\n",*(char*)(toto->next->content)); +** printf("toto->nxt->nxt->data:%c\n",*(char*)(toto->next->next->content)); +** printf("toto->nxt->nxt->nxt :%s\n",(char*)(toto->next->next->next)); +** return (0); +** } +*/ + +#include "libft.h" + +void ft_lstiter(t_list *lst, void (*f)(void *)) +{ + if (!lst) + return ; + if (lst->next) + ft_lstiter(lst->next, f); + f(lst); +} diff --git a/srcs/ft_lstlast.c b/srcs/ft_lstlast.c new file mode 100644 index 0000000..630b66a --- /dev/null +++ b/srcs/ft_lstlast.c @@ -0,0 +1,99 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstlast.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 14:14:49 by hulamy #+# #+# */ +/* Updated: 2019/11/25 14:30:20 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** return a pointer to the last element of a list +*/ + +/* +** #include +** +** typedef struct s_list +** { +** void *content; +** struct s_list *next; +** } t_list; +** +** void *ft_memcpy(void *dst, const void *src, size_t n) +** { +** size_t i; +** char *ptr; +** char *ptr2; +** +** ptr = (char *)dst; +** ptr2 = (char *)src; +** i = -1; +** while (++i < n) +** ptr[i] = ptr2[i]; +** return (dst); +** } +** +** t_list *ft_lstnew(void *content) +** { +** t_list *lst; +** +** if (!(lst = (t_list *)malloc(sizeof(*lst)))) +** return (NULL); +** if (!content) +** lst->content = NULL; +** else +** { +** if (!(lst->content = malloc(sizeof(content)))) +** return (NULL); +** ft_memcpy(lst->content, content, sizeof(content)); +** } +** lst->next = NULL; +** return (lst); +** } +** +** void ft_lstadd_front(t_list **alst, t_list *new) +** { +** new->next = *alst; +** *alst = new; +** } +** +** t_list *ft_lstlast(t_list *lst); +** +** int main(void) +** { +** char tresor; +** t_list *toto; +** t_list *tmp; +** +** tresor = 'a'; +** toto = ft_lstnew(&tresor); +** tresor = 'b'; +** tmp = ft_lstnew(&tresor); +** ft_lstadd_front(&toto, tmp); +** tresor = 'c'; +** tmp = ft_lstnew(&tresor); +** ft_lstadd_front(&toto, tmp); +** printf("toto->data :%c\n",*(char*)(toto->content)); +** printf("toto->nxt->data :%c\n",*(char*)(toto->next->content)); +** printf("toto->nxt->nxt->data:%c\n",*(char*)(toto->next->next->content)); +** tmp = ft_lstlast(toto); +** printf("%c\n",*(char*)(tmp->content)); +** printf("toto->data :%c\n",*(char*)(toto->content)); +** printf("toto->nxt->data :%c\n",*(char*)(toto->next->content)); +** printf("toto->nxt->nxt->data:%c\n",*(char*)(toto->next->next->content)); +** return (0); +** } +*/ + +#include "libft.h" + +t_list *ft_lstlast(t_list *lst) +{ + while (lst->next) + lst = lst->next; + return (lst); +} diff --git a/srcs/ft_lstmap.c b/srcs/ft_lstmap.c new file mode 100644 index 0000000..26d9002 --- /dev/null +++ b/srcs/ft_lstmap.c @@ -0,0 +1,119 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstmap.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 14:15:42 by hulamy #+# #+# */ +/* Updated: 2019/11/25 14:34:19 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** iterate trhough linked list and apply to each element a function f +** if necessary the function del is used to delete an element +*/ + +/* +** #include +** +** typedef struct s_list +** { +** void *content; +** struct s_list *next; +** } t_list; +** +** t_list *ft_lstnew(void *content) +** { +** t_list *lst; +** +** if (!(lst = (t_list *)malloc(sizeof(*lst)))) +** return (NULL); +** if (!content) +** lst->content = NULL; +** else +** lst->content = content; +** lst->next = NULL; +** return (lst); +** } +** +** void ft_lstadd_back(t_list **alst, t_list *new) +** { +** t_list *tmp; +** +** if (alst) +** { +** tmp = *alst; +** if (!tmp) +** *alst = new; +** else +** { +** while (tmp->next) +** tmp = tmp->next; +** tmp->next = new; +** } +** new->next = NULL; +** } +** } +** +** void *to_uppercase(void *element) +** { +** *(char*)(((t_list*)element)->content) -= 32; +** return (element); +** } +** +** void ft_delete(void *element) +** { +** *(char*)element = '\0'; +** } +** +** t_list *ft_lstmap(t_list *lst, void *(*f)(void *), void (*del)(void *)); +** +** int main(void) +** { +** t_list *toto; +** void *(to_uppercase)(void *); +** void (ft_delete)(void*); +** +** toto = ft_lstnew("a"); +** toto->next = ft_lstnew("b"); +** toto->next->next = ft_lstnew("c"); +** printf("toto->data :%c\n",*(char*)(toto->content)); +** printf("toto->nxt->data :%c\n",*(char*)(toto->next->content)); +** printf("toto->nxt->nxt->data:%c\n",*(char*)(toto->next->next->content)); +** printf("toto->nxt->nxt->nxt :%s\n",(char*)(toto->next->next->next)); +** ft_lstmap(toto->next, to_uppercase, ft_delete); +** printf("----------------------\n"); +** printf("toto->data :%c\n",*(char*)(toto->content)); +** printf("toto->nxt->data :%c\n",*(char*)(toto->next->content)); +** printf("toto->nxt->nxt->data:%c\n",*(char*)(toto->next->next->content)); +** printf("toto->nxt->nxt->nxt :%s\n",(char*)(toto->next->next->next)); +** return (0); +** } +*/ + +#include "libft.h" + +t_list *ft_lstmap(t_list *lst, void *(*f)(void *), void (*del)(void *)) +{ + t_list *new; + t_list *tmp; + + if (!lst) + return (NULL); + tmp = (t_list*)f(lst); + new = tmp; + while (lst->next) + { + lst = lst->next; + if (!(tmp->next = (t_list*)f(lst))) + { + del(tmp->next->content); + free(tmp->next); + return (NULL); + } + tmp = tmp->next; + } + return (new); +} diff --git a/srcs/ft_lstnew.c b/srcs/ft_lstnew.c new file mode 100644 index 0000000..401f6c9 --- /dev/null +++ b/srcs/ft_lstnew.c @@ -0,0 +1,59 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstnew.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 14:16:20 by hulamy #+# #+# */ +/* Updated: 2019/11/25 14:29:46 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** create a new list +*/ + +/* +** #include +** +** typedef struct s_list +** { +** void *content; +** struct s_list *next; +** } t_list; +** +** t_list *ft_lstnew(void *content); +** +** int main(void) +** { +** char tresor; +** t_list *toto; +** +** tresor = 'd'; +** printf("tresor : %c\n",tresor); +** toto = ft_lstnew(&tresor); +** //toto->content was alocated as void* so it need cast +** printf("toto->content : %c\n",*(char*)(toto->content)); +** tresor = 'D'; +** printf("transform tresor : %c\n",tresor); +** printf("and also toto->content: %c\n",*(char*)(toto->content)); +** return (0); +** } +*/ + +#include "libft.h" + +t_list *ft_lstnew(void *content) +{ + t_list *lst; + + if (!(lst = (t_list *)malloc(sizeof(*lst)))) + return (NULL); + if (!content) + lst->content = NULL; + else + lst->content = content; + lst->next = NULL; + return (lst); +} diff --git a/srcs/ft_lstsize.c b/srcs/ft_lstsize.c new file mode 100644 index 0000000..5ff5f2d --- /dev/null +++ b/srcs/ft_lstsize.c @@ -0,0 +1,86 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_lstsize.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 14:31:48 by hulamy #+# #+# */ +/* Updated: 2019/11/25 16:06:41 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** return the size of the linked list +*/ + +/* +** #include +** +** typedef struct s_list +** { +** void *content; +** struct s_list *next; +** } t_list; +** +** t_list *ft_lstnew(void *content) +** { +** t_list *lst; +** +** if (!(lst = (t_list *)malloc(sizeof(*lst)))) +** return (NULL); +** if (!content) +** lst->content = NULL; +** else +** lst->content = content; +** lst->next = NULL; +** return (lst); +** } +** +** void ft_lstadd_front(t_list **alst, t_list *new) +** { +** new->next = *alst; +** *alst = new; +** } +** +** int ft_lstsize(t_list *lst); +** +** int main(void) +** { +** char tresor; +** t_list *toto; +** t_list *tmp; +** +** tresor = 'a'; +** toto = ft_lstnew(&tresor); +** tresor = 'b'; +** tmp = ft_lstnew(&tresor); +** ft_lstadd_front(&toto, tmp); +** tresor = 'c'; +** tmp = ft_lstnew(&tresor); +** ft_lstadd_front(&toto, tmp); +** printf("toto->data :%c\n",*(char*)(toto->content)); +** printf("toto->nxt->data :%c\n",*(char*)(toto->next->content)); +** printf("toto->nxt->nxt->dqta:%c\n",*(char*)(toto->next->next->content)); +** printf("%i\n",ft_lstsize(toto)); +** printf("toto->data :%c\n",*(char*)(toto->content)); +** printf("toto->nxt->data :%c\n",*(char*)(toto->next->content)); +** printf("toto->nxt->nxt->dqta:%c\n",*(char*)(toto->next->next->content)); +** return (0); +** } +*/ + +#include "libft.h" + +int ft_lstsize(t_list *lst) +{ + int size; + + size = 0; + while (lst) + { + size++; + lst = lst->next; + } + return (size); +} diff --git a/srcs/ft_memalloc.c b/srcs/ft_memalloc.c new file mode 100644 index 0000000..072e7f1 --- /dev/null +++ b/srcs/ft_memalloc.c @@ -0,0 +1,27 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_memalloc.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/19 15:21:44 by hulamy #+# #+# */ +/* Updated: 2019/11/19 15:23:17 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** allocate size byte of memory and return a pointer to the allocated memory +*/ + +#include "libft.h" + +void *ft_memalloc(size_t size) +{ + void *tmp; + + if (!size || !(tmp = malloc(size))) + return (NULL); + ft_bzero(tmp, size); + return (tmp); +} diff --git a/srcs/ft_memccpy.c b/srcs/ft_memccpy.c new file mode 100644 index 0000000..fee3c2f --- /dev/null +++ b/srcs/ft_memccpy.c @@ -0,0 +1,36 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_memccpy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 15:24:51 by hulamy #+# #+# */ +/* Updated: 2019/11/25 15:25:09 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** copy string until character is found and place cursor in dst +** after last byte copied +*/ + +#include "libft.h" + +void *ft_memccpy(void *dst, const void *src, int c, size_t n) +{ + unsigned char *dest; + unsigned char *sourc; + size_t i; + + i = -1; + dest = (unsigned char *)dst; + sourc = (unsigned char *)src; + while (++i < n) + { + dest[i] = sourc[i]; + if (sourc[i] == (unsigned char)c) + return (dst + i + 1); + } + return (NULL); +} diff --git a/srcs/ft_memchr.c b/srcs/ft_memchr.c new file mode 100644 index 0000000..ab61ff4 --- /dev/null +++ b/srcs/ft_memchr.c @@ -0,0 +1,30 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_memchr.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:55:51 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:55:54 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** locate character in string and return its position +*/ + +#include "libft.h" + +void *ft_memchr(const void *s, int c, size_t n) +{ + unsigned char *sbis; + size_t i; + + sbis = (unsigned char *)s; + i = -1; + while (++i < n) + if (sbis[i] == (unsigned char)c) + return ((void *)sbis + i); + return (NULL); +} diff --git a/srcs/ft_memcmp.c b/srcs/ft_memcmp.c new file mode 100644 index 0000000..c05a028 --- /dev/null +++ b/srcs/ft_memcmp.c @@ -0,0 +1,32 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_memcmp.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:56:05 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:56:07 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** compare two bytes strings (doesnt recognize a null terminated string) +** and return value of difference between first two different character +*/ + +#include "libft.h" + +int ft_memcmp(const void *s1, const void *s2, size_t n) +{ + unsigned char *frst; + unsigned char *scnd; + size_t i; + + i = 0; + frst = (unsigned char *)s1; + scnd = (unsigned char *)s2; + while (i < n && frst[i] == scnd[i]) + i++; + return ((i == n) ? 0 : frst[i] - scnd[i]); +} diff --git a/srcs/ft_memcpy.c b/srcs/ft_memcpy.c new file mode 100644 index 0000000..8b869fb --- /dev/null +++ b/srcs/ft_memcpy.c @@ -0,0 +1,50 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_memcpy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:56:16 by hulamy #+# #+# */ +/* Updated: 2019/11/28 13:45:23 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** copy n characters from src to dst and return dst +*/ + +/* +** #include +** +** void *ft_memcpy(void *dst, const void *src, size_t n); +** +** int main(int ac, char **av) +** { +** if (ac == 4) +** { +** printf("%s\n", ft_memcpy(av[1], av[2], atoi(av[3]))); +** } +** else +** { +** printf("%s\n", ft_memcpy("troubadour", "bravo", 4)); +** } +** return (0); +** } +*/ + +#include "libft.h" + +void *ft_memcpy(void *dst, const void *src, size_t n) +{ + char *ptr; + char *ptr2; + + ptr = (char *)dst; + ptr2 = (char *)src; + if (dst == src) + return (dst); + while (n--) + ptr[n] = ptr2[n]; + return (dst); +} diff --git a/srcs/ft_memdel.c b/srcs/ft_memdel.c new file mode 100644 index 0000000..f057043 --- /dev/null +++ b/srcs/ft_memdel.c @@ -0,0 +1,26 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_memdel.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/14 21:13:26 by hulamy #+# #+# */ +/* Updated: 2019/04/03 15:44:12 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** free memory +*/ + +#include "libft.h" + +void ft_memdel(void **ap) +{ + if (ap && *ap) + { + free(*ap); + *ap = 0; + } +} diff --git a/srcs/ft_memmove.c b/srcs/ft_memmove.c new file mode 100644 index 0000000..5ff017c --- /dev/null +++ b/srcs/ft_memmove.c @@ -0,0 +1,35 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_memmove.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:56:25 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:56:29 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** copy n characters from src to dst in a non destructive way and return dst +*/ + +#include "libft.h" + +void *ft_memmove(void *dst, const void *src, size_t len) +{ + int i; + char *source; + char *dest; + + i = -1; + source = (char *)src; + dest = (char *)dst; + if (source < dest) + while ((int)(--len) >= 0) + dest[len] = source[len]; + else + while (++i < (int)len) + dest[i] = source[i]; + return (dst); +} diff --git a/srcs/ft_memset.c b/srcs/ft_memset.c new file mode 100644 index 0000000..10c2d7c --- /dev/null +++ b/srcs/ft_memset.c @@ -0,0 +1,29 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_memset.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:56:37 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:56:38 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** copy n time a character in a string and return the string +*/ + +#include "libft.h" + +void *ft_memset(void *b, int c, size_t len) +{ + char *ptr; + size_t i; + + ptr = (char *)b; + i = 0; + while (i < len) + ptr[i++] = c; + return (b); +} diff --git a/srcs/ft_putchar.c b/srcs/ft_putchar.c new file mode 100644 index 0000000..b0aa9cb --- /dev/null +++ b/srcs/ft_putchar.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_putchar.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/14 21:14:00 by hulamy #+# #+# */ +/* Updated: 2018/11/14 21:14:01 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_putchar(char c) +{ + write(1, &c, 1); +} diff --git a/srcs/ft_putchar_fd.c b/srcs/ft_putchar_fd.c new file mode 100644 index 0000000..a48c1d5 --- /dev/null +++ b/srcs/ft_putchar_fd.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_putchar_fd.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:59:40 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:59:42 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_putchar_fd(char c, int fd) +{ + write(fd, &c, 1); +} diff --git a/srcs/ft_putendl.c b/srcs/ft_putendl.c new file mode 100644 index 0000000..c1d9a6a --- /dev/null +++ b/srcs/ft_putendl.c @@ -0,0 +1,19 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_putendl.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/14 21:14:32 by hulamy #+# #+# */ +/* Updated: 2018/11/14 21:14:33 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_putendl(char const *s) +{ + ft_putstr(s); + ft_putchar('\n'); +} diff --git a/srcs/ft_putendl_fd.c b/srcs/ft_putendl_fd.c new file mode 100644 index 0000000..5a0ef44 --- /dev/null +++ b/srcs/ft_putendl_fd.c @@ -0,0 +1,23 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_putendl_fd.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:59:47 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:59:48 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** write the string s on the given file descriptor fd, followed by a newline +*/ + +#include "libft.h" + +void ft_putendl_fd(char *s, int fd) +{ + ft_putstr_fd(s, fd); + ft_putchar_fd('\n', fd); +} diff --git a/srcs/ft_putnbr.c b/srcs/ft_putnbr.c new file mode 100644 index 0000000..bb8e2d7 --- /dev/null +++ b/srcs/ft_putnbr.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_putnbr.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/14 21:14:57 by hulamy #+# #+# */ +/* Updated: 2018/11/14 21:14:58 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_putnbr(int n) +{ + ft_putnbr_fd(n, 1); +} diff --git a/srcs/ft_putnbr_fd.c b/srcs/ft_putnbr_fd.c new file mode 100644 index 0000000..afc9e85 --- /dev/null +++ b/srcs/ft_putnbr_fd.c @@ -0,0 +1,28 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_putnbr_fd.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:59:56 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:59:57 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_putnbr_fd(int n, int fd) +{ + long l; + + l = n; + if (l < 0) + { + ft_putchar_fd('-', fd); + l *= -1; + } + if (l >= 10) + ft_putnbr_fd(l / 10, fd); + ft_putchar_fd((l % 10) + '0', fd); +} diff --git a/srcs/ft_putnbrbase.c b/srcs/ft_putnbrbase.c new file mode 100644 index 0000000..bf0d627 --- /dev/null +++ b/srcs/ft_putnbrbase.c @@ -0,0 +1,59 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_putnbrbase.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/16 15:17:00 by hulamy #+# #+# */ +/* Updated: 2018/11/16 15:23:43 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +static int check(char *base) +{ + int i; + int j; + + i = 0; + while (base[i]) + { + j = i + 1; + while (base[j]) + { + if (base[i] == base[j]) + return (0); + j++; + } + if (base[i] == '-' || base[i] == '+') + return (0); + i++; + } + if (i >= 2) + return (1); + return (0); +} + +void ft_putnbrbase(int nbr, char *base) +{ + int i; + long n; + + i = 0; + n = nbr; + if (check(base)) + { + if (n < 0) + { + ft_putchar('-'); + n = -n; + } + while (base[i]) + i++; + if (n >= i) + ft_putnbrbase(n / i, base); + ft_putchar(base[n % i]); + } +} diff --git a/srcs/ft_putnbrendl.c b/srcs/ft_putnbrendl.c new file mode 100644 index 0000000..ddd05f6 --- /dev/null +++ b/srcs/ft_putnbrendl.c @@ -0,0 +1,18 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_putnbrendl.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/02/19 10:38:07 by hulamy #+# #+# */ +/* Updated: 2019/02/19 10:42:46 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_putnbrendl(int n) +{ + ft_putnbrendl_fd(n, 1); +} diff --git a/srcs/ft_putnbrendl_fd.c b/srcs/ft_putnbrendl_fd.c new file mode 100644 index 0000000..266dc55 --- /dev/null +++ b/srcs/ft_putnbrendl_fd.c @@ -0,0 +1,29 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_putnbrendl_fd.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/02/19 10:37:58 by hulamy #+# #+# */ +/* Updated: 2019/02/19 10:42:48 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_putnbrendl_fd(int n, int fd) +{ + long l; + + l = n; + if (l < 0) + { + ft_putchar_fd('-', fd); + l *= -1; + } + if (l >= 10) + ft_putnbr_fd(l / 10, fd); + ft_putchar_fd((l % 10) + '0', fd); + ft_putchar_fd('\n', fd); +} diff --git a/srcs/ft_putstr.c b/srcs/ft_putstr.c new file mode 100644 index 0000000..78617eb --- /dev/null +++ b/srcs/ft_putstr.c @@ -0,0 +1,22 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_putstr.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/14 21:15:19 by hulamy #+# #+# */ +/* Updated: 2018/11/14 21:15:19 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +void ft_putstr(char const *s) +{ + int i; + + i = 0; + while (s && s[i]) + ft_putchar(s[i++]); +} diff --git a/srcs/ft_putstr_fd.c b/srcs/ft_putstr_fd.c new file mode 100644 index 0000000..cf6ad12 --- /dev/null +++ b/srcs/ft_putstr_fd.c @@ -0,0 +1,23 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_putstr_fd.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 14:00:04 by hulamy #+# #+# */ +/* Updated: 2019/11/25 14:00:05 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** write the string s on the given file descritor fd +*/ + +#include "libft.h" + +void ft_putstr_fd(char *s, int fd) +{ + while (s && *s) + ft_putchar_fd(*s++, fd); +} diff --git a/srcs/ft_split.c b/srcs/ft_split.c new file mode 100644 index 0000000..8f8dab5 --- /dev/null +++ b/srcs/ft_split.c @@ -0,0 +1,123 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_split.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 14:00:13 by hulamy #+# #+# */ +/* Updated: 2019/11/27 21:35:21 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** return an array of string with each word found in str, with c as separator +*/ + +/* +** #include +** +** size_t ft_strlen(const char *str) +** { +** size_t i; +** +** i = 0; +** while (str[i]) +** i++; +** return (i); +** } +** +** char *ft_substr(char const *s, unsigned int start, size_t len) +** { +** char *str; +** size_t i; +** +** if (!s) +** return (NULL); +** if (ft_strlen(s) < start) +** return (""); +** if (!(str = (char *)malloc(sizeof(char) * (len + 1)))) +** return (NULL); +** i = 0; +** while (i < len && s[start]) +** str[i++] = s[start++]; +** str[i] = '\0'; +** return (str); +** } +** +** char **ft_split(char const *s, char c); +** +** int main(int ac, char **av) +** //int main(void) +** { +** char **str; +** int i; +** +** char *s; +** char c; +** +** if (ac == 3) +** { +** i = 0; +** s = av[1]; +** // s = "lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed non risus. Suspendisse"; +** c = av[2][0]; +** // c = ' '; +** str = ft_split(s, c); +** while (str[i]) +** printf("%s\n", str[i++]); +** } +** return (0); +** } +*/ + +#include "libft.h" + +static int ft_count_word(char const *s, char c) +{ + int i; + int words; + + i = 0; + words = 0; + while (s[i]) + { + if (s[i] != c) + { + words++; + while (s[i] && s[i] != c) + i++; + } + else + i++; + } + return (words); +} + +char **ft_split(char const *s, char c) +{ + char **array; + int i; + int j; + int len; + + i = -1; + j = 0; + if (!s || !c) + return (NULL); + if (!(array = (char **)malloc(sizeof(char *) * (ft_count_word(s, c) + 1)))) + return (NULL); + while (s[++i]) + { + if (s[i] != c) + { + len = 0; + while (s[i + len] && s[i + len] != c) + len++; + array[j++] = ft_substr(s, i, len); + i = i + len - 1; + } + } + array[j] = 0; + return (array); +} diff --git a/srcs/ft_strcat.c b/srcs/ft_strcat.c new file mode 100644 index 0000000..d78543c --- /dev/null +++ b/srcs/ft_strcat.c @@ -0,0 +1,32 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strcat.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/14 21:15:40 by hulamy #+# #+# */ +/* Updated: 2019/03/25 15:12:58 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** append src to dest (dest must have sufficient space) and return dest +*/ + +#include "libft.h" + +char *ft_strcat(char *dest, const char *src) +{ + int i; + int j; + + i = 0; + j = 0; + while (dest[i]) + i++; + while (src[j]) + dest[i++] = src[j++]; + dest[i] = '\0'; + return (dest); +} diff --git a/srcs/ft_strchr.c b/srcs/ft_strchr.c new file mode 100644 index 0000000..b220565 --- /dev/null +++ b/srcs/ft_strchr.c @@ -0,0 +1,33 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strchr.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:56:46 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:56:47 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** locate the first occurence of character c in string s +** and return pointer to its location +*/ + +#include "libft.h" + +char *ft_strchr(const char *s, int c) +{ + int i; + int j; + + i = 0; + j = -1; + while (s[i]) + i++; + while (++j < i + 1) + if (s[j] == c) + return ((char *)s + j); + return (NULL); +} diff --git a/srcs/ft_strclr.c b/srcs/ft_strclr.c new file mode 100644 index 0000000..5e3952c --- /dev/null +++ b/srcs/ft_strclr.c @@ -0,0 +1,23 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strclr.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/14 21:15:58 by hulamy #+# #+# */ +/* Updated: 2019/03/25 15:17:42 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** fill string with zeros +*/ + +#include "libft.h" + +void ft_strclr(char *s) +{ + if (s) + ft_bzero(s, ft_strlen(s)); +} diff --git a/srcs/ft_strcmp.c b/srcs/ft_strcmp.c new file mode 100644 index 0000000..f6603c3 --- /dev/null +++ b/srcs/ft_strcmp.c @@ -0,0 +1,28 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strcmp.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/14 21:16:08 by hulamy #+# #+# */ +/* Updated: 2019/03/25 15:18:30 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** compare two null terminated strings and return value +** of difference between first two different character +*/ + +#include "libft.h" + +int ft_strcmp(const char *s1, const char *s2) +{ + int i; + + i = 0; + while (s1[i] && s1[i] == s2[i]) + i++; + return ((unsigned char)s1[i] - (unsigned char)s2[i]); +} diff --git a/srcs/ft_strcpy.c b/srcs/ft_strcpy.c new file mode 100644 index 0000000..7d2a45b --- /dev/null +++ b/srcs/ft_strcpy.c @@ -0,0 +1,28 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strcpy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/14 21:16:17 by hulamy #+# #+# */ +/* Updated: 2019/03/25 15:19:19 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** copy string src to dst including '\0' and return dst +*/ + +#include "libft.h" + +char *ft_strcpy(char *dest, const char *src) +{ + int i; + + i = -1; + while (src[++i]) + dest[i] = src[i]; + dest[i] = '\0'; + return (dest); +} diff --git a/srcs/ft_strdel.c b/srcs/ft_strdel.c new file mode 100644 index 0000000..82cbc2e --- /dev/null +++ b/srcs/ft_strdel.c @@ -0,0 +1,26 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strdel.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/14 21:16:25 by hulamy #+# #+# */ +/* Updated: 2019/03/25 15:19:54 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** free memory +*/ + +#include "libft.h" + +void ft_strdel(char **as) +{ + if (as && *as) + { + free(*as); + *as = 0; + } +} diff --git a/srcs/ft_strdup.c b/srcs/ft_strdup.c new file mode 100644 index 0000000..b917ac9 --- /dev/null +++ b/srcs/ft_strdup.c @@ -0,0 +1,32 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strdup.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:56:54 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:56:55 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** save a copy of string src by allocating memory and return pointer to copy +*/ + +#include "libft.h" + +char *ft_strdup(const char *src) +{ + int i; + char *str; + + i = 0; + while (src[i] != '\0') + i++; + if (!(str = (char*)malloc(sizeof(*str) * (i + 1)))) + return (NULL); + while (i-- >= 0) + str[i + 1] = src[i + 1]; + return (str); +} diff --git a/srcs/ft_strequ.c b/srcs/ft_strequ.c new file mode 100644 index 0000000..fa4d4e4 --- /dev/null +++ b/srcs/ft_strequ.c @@ -0,0 +1,24 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strequ.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/14 21:16:44 by hulamy #+# #+# */ +/* Updated: 2019/03/25 15:21:02 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** return 0 if strings s1 and s2 are identical and 1 if not +*/ + +#include "libft.h" + +int ft_strequ(char const *s1, char const *s2) +{ + if (!s1 || !s2) + return (0); + return (ft_strcmp(s1, s2) == 0); +} diff --git a/srcs/ft_striter.c b/srcs/ft_striter.c new file mode 100644 index 0000000..9d3b21f --- /dev/null +++ b/srcs/ft_striter.c @@ -0,0 +1,23 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_striter.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/14 21:16:53 by hulamy #+# #+# */ +/* Updated: 2019/03/25 15:21:14 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** apply function f to each element of string s +*/ + +#include "libft.h" + +void ft_striter(char *s, void (*f)(char *)) +{ + while (s && *s && f) + f(s++); +} diff --git a/srcs/ft_striteri.c b/srcs/ft_striteri.c new file mode 100644 index 0000000..60fd7f6 --- /dev/null +++ b/srcs/ft_striteri.c @@ -0,0 +1,26 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_striteri.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/14 21:17:04 by hulamy #+# #+# */ +/* Updated: 2019/03/25 15:21:27 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** apply function f to each element of string s with index specified +*/ + +#include "libft.h" + +void ft_striteri(char *s, void (*f)(unsigned int, char *)) +{ + int i; + + i = 0; + while (s && *s && f) + f(i++, s++); +} diff --git a/srcs/ft_strjoin.c b/srcs/ft_strjoin.c new file mode 100644 index 0000000..a325582 --- /dev/null +++ b/srcs/ft_strjoin.c @@ -0,0 +1,54 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strjoin.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 14:01:26 by hulamy #+# #+# */ +/* Updated: 2019/11/25 14:01:34 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** create a new string by concatenating the two strings s1 and s2 +*/ + +#include "libft.h" + +static char *ft_doit(char const *s1, char const *s2, char *dest) +{ + int j; + int i; + + j = 0; + i = 0; + while (s1[j] != '\0') + { + dest[i] = s1[j]; + i++; + j++; + } + j = 0; + while (s2[j] != '\0') + { + dest[i] = s2[j]; + i++; + j++; + } + dest[i] = '\0'; + return (dest); +} + +char *ft_strjoin(char const *s1, char const *s2) +{ + char *str; + + if (!s1 || !s2) + return (NULL); + if (!(str = (char *)malloc(sizeof(char) * + (ft_strlen(s1) + ft_strlen(s2) + 1)))) + return (NULL); + str = ft_doit(s1, s2, str); + return (str); +} diff --git a/srcs/ft_strjoinfree.c b/srcs/ft_strjoinfree.c new file mode 100644 index 0000000..8e0247b --- /dev/null +++ b/srcs/ft_strjoinfree.c @@ -0,0 +1,28 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strjoinfree.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/03/05 15:05:28 by hulamy #+# #+# */ +/* Updated: 2019/03/25 15:22:28 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** create a new string by concatenating the two strings s1 +** and s2 then freeing them +*/ + +#include "libft.h" + +char *ft_strjoinfree(char *s1, char *s2) +{ + char *str; + + if (!(str = ft_strjoin(s1, s2))) + return (NULL); + free(s1); + return (str); +} diff --git a/srcs/ft_strlcat.c b/srcs/ft_strlcat.c new file mode 100644 index 0000000..91d14d8 --- /dev/null +++ b/srcs/ft_strlcat.c @@ -0,0 +1,108 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strlcat.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:57:02 by hulamy #+# #+# */ +/* Updated: 2019/11/25 14:23:18 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** append src to sized dest and return size of final dest +*/ + +/* +** #include +** +** size_t ft_strlcat(char *dest, const char *src, size_t size); +** +** size_t ft_strlcat2(char *dest, char *src, size_t size); +** +** int ft_strlen(char *str) +** { +** int i; +** +** i = 0; +** while (str[i]) +** i++; +** return (i); +** } +** +** int main(int ac, char **av) +** { +** char tmp1[100]; +** char tmp2[100]; +** int i; +** +** i = atoi(av[3]); +** strcpy(tmp1, av[1]); +** strcpy(tmp2, av[2]); +** +** if (ac == 4) +** { +** printf("----strlcat: %zu - %s - %s\n", strlcat(tmp1, tmp2, i), +** tmp1, tmp2); +** +** strcpy(tmp1, av[1]); +** strcpy(tmp2, av[2]); +** +** printf("-ft_strlcat: %zu - %s - %s\n", ft_strlcat(tmp1, tmp2, i), +** tmp1, tmp2); +** +** strcpy(tmp1, av[1]); +** strcpy(tmp2, av[2]); +** +** printf("ft_strlcat2: %zu - %s - %s\n", ft_strlcat2(tmp1, tmp2, i), +** tmp1, tmp2); +** } +** } +** +** size_t ft_strlcat2(char *dest, char *src, size_t size) +** { +** size_t i; +** size_t dest_length; +** size_t src_length; +** +** i = 0; +** dest_length = ft_strlen(dest); +** src_length = ft_strlen(src); +** if (size > dest_length + 1) +** { +** while (i < (size - dest_length - 1)) +** { +** dest[i + dest_length] = src[i]; +** i++; +** } +** dest[dest_length + i] = '\0'; +** } +** if (size >= dest_length) +** return (dest_length + src_length); +** return (src_length + size); +** } +*/ + +#include "libft.h" + +size_t ft_strlcat(char *dest, const char *src, size_t size) +{ + size_t i; + size_t j; + + i = 0; + j = 0; + while (dest[i] && i < size) + i++; + while (src[j]) + { + if (j + i < size - 1 && size) + { + dest[i + j] = src[j]; + dest[i + j + 1] = '\0'; + } + j++; + } + return (i + j); +} diff --git a/srcs/ft_strlcpy.c b/srcs/ft_strlcpy.c new file mode 100644 index 0000000..9b33a47 --- /dev/null +++ b/srcs/ft_strlcpy.c @@ -0,0 +1,66 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strlcpy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:57:19 by hulamy #+# #+# */ +/* Updated: 2019/11/25 15:53:19 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** copy size - 1 length of src into dest, +** terminate it with a '\0' +** and return size of src +*/ + +/* +** #include +** +** size_t ft_strlcpy(char *dest, const char *src, size_t size); +** +** int main(int argc, char **argv) +** { +** char str[100]; +** int i; +** unsigned int u; +** unsigned int v; +** +** i = atoi(argv[3]); +** strcpy(str, argv[2]); +** if (argc > 3) +** { +** u = strlcpy(argv[2], argv[1], i); +** printf("strlcpy : %s - %s - %d",argv[1], argv[2], i); +** printf(" - return:%d\n",u); +** strcpy(argv[2], str); +** printf("(re-init : %s - %s - %d)\n",argv[1], argv[2], i); +** v = ft_strlcpy(argv[2], argv[1], i); +** printf("ft_strlcpy: %s - %s - %d",argv[1], argv[2], i); +** printf(" - return:%d\n",v); +** } +** return (0); +** } +*/ + +#include "libft.h" + +size_t ft_strlcpy(char *dest, const char *src, size_t size) +{ + size_t i; + size_t j; + + i = 0; + j = 0; + while (src[i] != '\0') + { + if (i + 1 < size) + dest[i] = src[j++]; + i++; + } + if (size > 0) + dest[j] = '\0'; + return (i); +} diff --git a/srcs/ft_strlen.c b/srcs/ft_strlen.c new file mode 100644 index 0000000..8af143b --- /dev/null +++ b/srcs/ft_strlen.c @@ -0,0 +1,27 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strlen.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:57:48 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:57:49 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** return length of of string +*/ + +#include "libft.h" + +size_t ft_strlen(const char *str) +{ + size_t i; + + i = 0; + while (str[i]) + i++; + return (i); +} diff --git a/srcs/ft_strmap.c b/srcs/ft_strmap.c new file mode 100644 index 0000000..ef82f97 --- /dev/null +++ b/srcs/ft_strmap.c @@ -0,0 +1,32 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strmap.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/14 21:17:49 by hulamy #+# #+# */ +/* Updated: 2019/03/25 15:23:12 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** create a new array with the result of function f on every element of s +*/ + +#include "libft.h" + +char *ft_strmap(char const *s, char (*f)(char)) +{ + char *str; + int i; + + if (!s) + return (NULL); + if (!(str = ft_strnew(ft_strlen(s)))) + return (NULL); + i = -1; + while (s[++i]) + str[i] = f(s[i]); + return (str); +} diff --git a/srcs/ft_strmapi.c b/srcs/ft_strmapi.c new file mode 100644 index 0000000..16060f2 --- /dev/null +++ b/srcs/ft_strmapi.c @@ -0,0 +1,72 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strmapi.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 14:01:40 by hulamy #+# #+# */ +/* Updated: 2019/11/25 14:19:43 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** create a new array with the result of function f on every element of +** s by index i +*/ + +/* +** #include +** +** size_t ft_strlen(const char *str) +** { +** size_t i; +** +** i = 0; +** while (str[i]) +** i++; +** return (i); +** } +** char touppercase(unsigned int i, char c) +** { +** if (i < 3) +** c -= 32; +** return (c); +** } +** +** char *ft_strmapi(char const *s, char (*f)(unsigned int, char)); +** +** int main(int ac, char **av) +** { +** char *str; +** char touppercase(unsigned int, char); +** +** if (ac != 2) +** return (0); +** str = av[1]; +** printf("%s\n",str); +** str = ft_strmapi(str, touppercase); +** printf("%s\n",str); +** return (0); +** } +*/ + +#include "libft.h" + +char *ft_strmapi(char const *s, char (*f)(unsigned int, char)) +{ + char *str; + int i; + int size; + + if (!s) + return (NULL); + size = ft_strlen(s); + if (!(str = (char *)malloc(sizeof(char) * (size + 1)))) + return (NULL); + str[size] = '\0'; + i = -1; + while (s[++i]) + str[i] = f(i, s[i]); + return (str); +} diff --git a/srcs/ft_strmultisplit.c b/srcs/ft_strmultisplit.c new file mode 100644 index 0000000..ed2ed98 --- /dev/null +++ b/srcs/ft_strmultisplit.c @@ -0,0 +1,83 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strmultisplit.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/16 15:18:29 by hulamy #+# #+# */ +/* Updated: 2019/03/25 15:23:57 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** return an array of string with each word found in str +** with any character of charset difining a separator +*/ + +#include "libft.h" + +static int ft_is_separator(char c, char *charset, int i) +{ + while (charset[i]) + { + if (c == charset[i]) + return (1); + i++; + } + c = charset[i]; + return (0); +} + +static int ft_count(char *str, int word, char **tab, char *charset) +{ + int i; + int j; + int k; + + k = 0; + i = 0; + while (ft_is_separator(str[k], charset, 0) == 1) + k++; + while (str[k] != '\0' && i != word) + { + j = 0; + while (!ft_is_separator(str[k + j], charset, 0) && str[k + j] != '\0') + { + if (word == -2) + tab[i][j] = str[k + j]; + j++; + } + k += j; + while (ft_is_separator(str[k], charset, 0)) + k++; + i++; + } + if (word == -1) + return (i); + return (j); +} + +char **ft_strmultisplit(char *str, char *charset) +{ + char **tab; + int i; + int j; + int k; + + k = 0; + tab = 0; + i = ft_count(str, -1, tab, charset); + if (!(tab = (char**)malloc(sizeof(tab) * (i + 1)))) + return (NULL); + tab[i] = 0; + while (k < i) + { + j = ft_count(str, k + 1, tab, charset); + tab[k] = (char*)malloc(sizeof(*tab) * (j + 1)); + tab[k][j] = '\0'; + k++; + } + ft_count(str, -2, tab, charset); + return (tab); +} diff --git a/srcs/ft_strncat.c b/srcs/ft_strncat.c new file mode 100644 index 0000000..cf52aae --- /dev/null +++ b/srcs/ft_strncat.c @@ -0,0 +1,32 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strncat.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/14 21:18:24 by hulamy #+# #+# */ +/* Updated: 2019/03/25 15:24:11 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** append n character of src to dest and return dest +*/ + +#include "libft.h" + +char *ft_strncat(char *dest, const char *src, size_t nb) +{ + size_t i; + size_t j; + + i = 0; + j = 0; + while (dest[i]) + i++; + while (src[j] && j < nb) + dest[i++] = src[j++]; + dest[i] = '\0'; + return (dest); +} diff --git a/srcs/ft_strncmp.c b/srcs/ft_strncmp.c new file mode 100644 index 0000000..7022624 --- /dev/null +++ b/srcs/ft_strncmp.c @@ -0,0 +1,32 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strncmp.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:57:59 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:58:00 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** compare size first character of two null terminated strings +** and return value of difference between first two different character +*/ + +#include "libft.h" + +int ft_strncmp(const char *s1, const char *s2, size_t n) +{ + size_t i; + int res; + + i = 0; + res = 0; + while (s1[i] && s1[i] == s2[i] && i < n - 1) + i++; + if (n != 0) + res = (unsigned char)s1[i] - (unsigned char)s2[i]; + return (res); +} diff --git a/srcs/ft_strncpy.c b/srcs/ft_strncpy.c new file mode 100644 index 0000000..91ea1b3 --- /dev/null +++ b/srcs/ft_strncpy.c @@ -0,0 +1,30 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strncpy.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/14 21:18:44 by hulamy #+# #+# */ +/* Updated: 2019/03/25 15:24:59 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** copy n characters from string src to dst including '\0' +** if space remain it's filled zith '\0', and return dst +*/ + +#include "libft.h" + +char *ft_strncpy(char *dest, const char *src, size_t n) +{ + size_t i; + + i = -1; + while (++i < n && src[i]) + dest[i] = src[i]; + while (i < n) + dest[i++] = '\0'; + return (dest); +} diff --git a/srcs/ft_strnequ.c b/srcs/ft_strnequ.c new file mode 100644 index 0000000..668f3fa --- /dev/null +++ b/srcs/ft_strnequ.c @@ -0,0 +1,25 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strnequ.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/14 21:18:55 by hulamy #+# #+# */ +/* Updated: 2019/03/25 15:25:20 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** return 0 if n first character of strings s1 and s2 are identical +** and 1 if not +*/ + +#include "libft.h" + +int ft_strnequ(char const *s1, char const *s2, size_t n) +{ + if (!s1 || !s2) + return (0); + return (ft_strncmp(s1, s2, n) == 0); +} diff --git a/srcs/ft_strnew.c b/srcs/ft_strnew.c new file mode 100644 index 0000000..645feff --- /dev/null +++ b/srcs/ft_strnew.c @@ -0,0 +1,27 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strnew.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/14 21:19:08 by hulamy #+# #+# */ +/* Updated: 2019/11/21 17:00:30 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** create a new string of length size, fill with zero, and return pointer to it +*/ + +#include "libft.h" + +char *ft_strnew(size_t size) +{ + char *str; + + if (!(str = (char *)malloc(sizeof(char) * (size + 1)))) + return (NULL); + ft_bzero(str, size + 1); + return (str); +} diff --git a/srcs/ft_strnstr.c b/srcs/ft_strnstr.c new file mode 100644 index 0000000..52ff0d2 --- /dev/null +++ b/srcs/ft_strnstr.c @@ -0,0 +1,42 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strnstr.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:58:10 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:58:11 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** locate the first occurence of the string little in len first characters +** of big and return a pointer to this occurence if found +*/ + +#include "libft.h" + +char *ft_strnstr(const char *big, const char *little, size_t len) +{ + size_t i; + size_t j; + + j = 0; + i = 0; + if (!ft_strlen(little)) + return ((char *)big); + while (i == 0 && j <= len) + { + while (little[i] == big[j + i] && little[i] && j + i <= len) + i++; + if (little[i]) + { + j++; + if (!big[j] || j >= len) + return (0); + i = 0; + } + } + return ((char *)big + j); +} diff --git a/srcs/ft_strrchr.c b/srcs/ft_strrchr.c new file mode 100644 index 0000000..1c8faa8 --- /dev/null +++ b/srcs/ft_strrchr.c @@ -0,0 +1,32 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strrchr.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:58:20 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:58:21 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** locate the last occurence of character c in string s +** and return pointer to its location +*/ + +#include "libft.h" + +char *ft_strrchr(const char *s, int c) +{ + int i; + + i = 0; + while (s[i]) + i++; + i++; + while (i--) + if (s[i] == c) + return ((char *)s + i); + return (NULL); +} diff --git a/srcs/ft_strstr.c b/srcs/ft_strstr.c new file mode 100644 index 0000000..c7a3535 --- /dev/null +++ b/srcs/ft_strstr.c @@ -0,0 +1,42 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strstr.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2018/11/14 21:19:45 by hulamy #+# #+# */ +/* Updated: 2019/03/25 15:26:59 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** locate the first occurence of the string little in big +** and return a pointer to this occurence if found +*/ + +#include "libft.h" + +char *ft_strstr(const char *str, const char *to_find) +{ + int i; + int j; + + j = 0; + i = 0; + if (!ft_strlen(to_find)) + return ((char *)str); + while (i == 0) + { + while (to_find[i] && to_find[i] == str[j + i]) + i++; + if (to_find[i]) + { + j++; + if (str[j] == '\0' && to_find[i]) + return (0); + i = 0; + } + } + return ((char *)str + j); +} diff --git a/srcs/ft_strtrim.c b/srcs/ft_strtrim.c new file mode 100644 index 0000000..46f6133 --- /dev/null +++ b/srcs/ft_strtrim.c @@ -0,0 +1,90 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_strtrim.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 14:01:49 by hulamy #+# #+# */ +/* Updated: 2019/11/25 14:20:41 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** create a copy of s without the firsts and lasts empty characters +*/ + +/* +** #include +** +** char *ft_substr(char const *s, unsigned int start, size_t len) +** { +** char *str; +** size_t i; +** +** if (!s) +** return (NULL); +** if (!(str = (char *)malloc(sizeof(char) * (len + 1)))) +** return (NULL); +** str[len] = '\0'; +** i = 0; +** while (i < len) +** str[i++] = s[start++]; +** return (str); +** } +** +** size_t ft_strlen(const char *str) +** { +** size_t i; +** +** i = 0; +** while (str[i]) +** i++; +** return (i); +** } +** +** char *ft_strchr(const char *s, int c) +** { +** int i; +** int j; +** +** i = 0; +** j = -1; +** while (s[i]) +** i++; +** while (++j < i + 1) +** if (s[j] == c) +** return ((char *)s + j); +** return (NULL); +** } +** +** char *ft_strtrim(char const *s1, char const *set); +** +** int main(int ac, char **av) +** { +** if (ac == 3) +** printf("%s\n",ft_strtrim(av[1], av[2])); +** +** return (0); +** } +*/ + +#include "libft.h" + +char *ft_strtrim(char const *s1, char const *set) +{ + int len; + char *str; + + if (!s1) + return (NULL); + while (s1[0] && ft_strchr(set, s1[0])) + s1++; + len = ft_strlen(s1) - 1; + while (len >= 0 && ft_strchr(set, s1[len])) + len--; + len++; + if (!(str = ft_substr(s1, 0, len))) + return (NULL); + return (str); +} diff --git a/srcs/ft_substr.c b/srcs/ft_substr.c new file mode 100644 index 0000000..3ea3480 --- /dev/null +++ b/srcs/ft_substr.c @@ -0,0 +1,52 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_substr.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 14:01:58 by hulamy #+# #+# */ +/* Updated: 2019/11/27 19:54:09 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +/* +** create a copy of a portion of s, begining at start and of length len +*/ + +/* +** #include +** +** char *ft_substr(char const *s, unsigned int start, size_t len); +** +** int main(int ac, char **av) +** { +** char *str; +** +** if (ac != 4) +** return (0); +** str = ft_substr(av[1], atoi(av[2]), atoi(av[3])); +** printf("%s\n",str); +** return (0); +** } +*/ + +#include "libft.h" + +char *ft_substr(char const *s, unsigned int start, size_t len) +{ + char *str; + size_t i; + + if (!s) + return (NULL); + if (ft_strlen(s) < start) + return (""); + if (!(str = (char *)malloc(sizeof(char) * (len + 1)))) + return (NULL); + i = 0; + while (i < len && s[start]) + str[i++] = s[start++]; + str[i] = '\0'; + return (str); +} diff --git a/srcs/ft_tolower.c b/srcs/ft_tolower.c new file mode 100644 index 0000000..2cd5cb6 --- /dev/null +++ b/srcs/ft_tolower.c @@ -0,0 +1,20 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_tolower.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:58:30 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:58:32 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_tolower(int c) +{ + if (c >= 'A' && c <= 'Z') + return (c + 32); + return (c); +} diff --git a/srcs/ft_toupper.c b/srcs/ft_toupper.c new file mode 100644 index 0000000..cc842a5 --- /dev/null +++ b/srcs/ft_toupper.c @@ -0,0 +1,20 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ft_toupper.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: hulamy +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2019/11/25 13:58:39 by hulamy #+# #+# */ +/* Updated: 2019/11/25 13:58:43 by hulamy ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "libft.h" + +int ft_toupper(int c) +{ + if (c >= 'a' && c <= 'z') + return (c - 32); + return (c); +} diff --git a/srcs/part2/a.out b/srcs/part2/a.out deleted file mode 100755 index 10b9e261959730ef4a13e36812ac3eb8a331481a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8640 zcmeHNUuaWT7(X#}%QojtVK|-JjAHjkhgK&;SqHbnyPeWz>(qb@%3YhLHjt(zf6#7* z6_P@3uR<8ed>M#OKKS5+Zv$y{7$;+mv|t`OD5Gu(&G5PxGuh03-?{g;N$U1E7~Bue z{mysJcYfzPzwcafdQWE`{r322#$0a3Ce|^=B$VkE#wM8$HO97}a1>ST?fg*rR5|i7 zwKj^Y(R`vsI7K+B>M`Z`u|^j$-rLy5EE}=0^;RJdRZWCWC8%afGhXj=SPZ&$VGSf? zTUE26g-w_h^Qo%wL~VCBO zP$&kr@mW!*E@E(BckMzQ)UL=ISU=%hv0o^whs=X0)JJP}Jz4_&uGLr&&(ZOCA~dq+ z{XK{)JOC%iYbb<&-e>AJEt~jq#9_c;z+u2)z+vFOVj#e^dt6IZd0sJSPOd9euKSIN z4iA$ut!9hC)6*`lDMtCHTCD~bqwj{aZG!y8_;f`EhM^@ZTnjAnbjo1TKSs+ zD+MUFZ#p}}^+18Y8(7TxXQed#GE=BD+imIE25Xs&xXvix|)J}nNUG@M4sG{zj@?`yYL0VC|mb_a! zN?w{$LT`x&{YyOEaSIuG%N$(N{Y%G)l6mv2PHO(sme>w_uge z{OT_KKz$nJa!uZrfhGc>rRx5L^o&dMFYw@Dmh(LO=Aol=&L% zd1W3?JKKh?EVz|<9z+B!`!P}0KPP3jS>u81_M`I-WnX|izy`?6+0@*WGPkk;=qRZx z^9Ws2=F1mFZc~PyL_mT0($>Fd#|IYmWKnw{0xk03W3IJ4GU3x@ioLvF48v-J{vyw} z+@c_{hQ+#V0m6rJ^uCx}SF_4PymThl70bVhS5HiW#anEAX(CmDj8zIY9ugaLpwyL$ z2)knKemEspsaTdWFFkRv#lrHGvfRXiA>fSiWrQU%R6c~?g1Hm1NGQrWao>&`-Veqi;RNe-v%)5Poyfh2 z$CWL36zCfZ8s!V?F1QRa5OyERMtlLA#@7%iaYrb*=zFJWZ-SQ4(TmTd)bF!x>;D0E zTXxQ}-?41Eha~?F6lkgnIgDq$-P2^#9V*@J(j6{DwrwA7uGey*5*K2