more cleanup

removing test maps & test files

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "libft"]
-	path = libft
-	url = https://github.com/tvdu29/libft

Makefile

@@ -6,11 +6,11 @@
 #    By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+         #
 #                                                 +#+#+#+#+#+   +#+            #
 #    Created: 2019/03/27 16:51:02 by tmaze             #+#    #+#              #
-#    Updated: 2019/04/01 14:49:54 by tmaze            ###   ########.fr        #
+#    Updated: 2019/05/09 18:39:33 by tmaze            ###   ########.fr        #
 #                                                                              #
 #******************************************************************************#
 
-NAME	=	lem_in
+NAME	=	lem-in
 
 #	Make options
 MAKEFLAGS	+=	--no-print-directory
@@ -27,7 +27,7 @@ endif
 
 #	Compilator
 CC		=	gcc
-FLAGS	=	-Wall -Wextra -Werror -g
+FLAGS	=	-Wall -Wextra -Werror
 
 #	Folders
 LIBDIR	=	libft
@@ -36,9 +36,25 @@ OBJDIR	=	objs
 INCDIR	=	includes libft/includes
 
 #	Source files
-SRC	=		bfs.c lm_parser.c lm_mem_utils.c lm_graph_utils.c	\
-			lst_ind.c	\
-			edmunds_karp.c
+SRC	=		lm_parser.c 			\
+			lm_mem_utils.c 			\
+			lm_check_errors.c		\
+			lm_data_utils.c			\
+			lm_initdata.c			\
+			lm_mem_utils.c			\
+			lm_graph_utils.c		\
+			lm_parser_error_check.c	\
+			lm_utils_parser.c		\
+			lm_utils_algo.c			\
+			bfs.c 					\
+			lst_ind.c				\
+			edmonds_karp.c 			\
+			push_ants.c				\
+			push_ants_utils.c		\
+			score_utils.c			\
+			print_map.c				\
+			lem_in.c
+
 
 OBJ		=	$(SRC:.c=.o)
 

includes/lem_in.h

@@ -6,15 +6,14 @@
 /*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2019/03/23 17:31:19 by tmaze             #+#    #+#             */
-/*   Updated: 2019/04/03 15:57:39 by tmaze            ###   ########.fr       */
+/*   Updated: 2019/05/09 17:39:33 by mndhlovu         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #ifndef LEM_IN_H
 # define LEM_IN_H
-
 # include "libft.h"
-# include <fcntl.h>
+# include "limits.h"
 
 typedef struct		s_node
 {
@@ -33,88 +32,125 @@ typedef struct		s_ind
 	struct s_ind	*next;
 }					t_ind;
 
-typedef	struct		s_lmdata
-{
-	int				nbants;
-	int				nb_nodes;
-	t_list			*nodes;
-	t_node			*nodes_data;
-	t_ind			**adj;
-}					t_lmdata;
-
 typedef struct		s_bfs
 {
 	int				parent;
 	char			visited;
+	char			old_visited;
 	int				queue;
 }					t_bfs;
 
-//LEM_IN MT STRUCTS
-
-typedef struct		s_syntax
+typedef struct		s_ants
 {
+	int				nb_ant;
+	int				nb_path;
+	int				nb_node;
+	char			end;
+	struct s_ants	*next;
+}					t_ants;
+
+typedef struct		s_temp
+{
+	int				src_ind;
+	int				dest_ind;
+	struct s_temp	*next;
+}					t_temp;
+
+typedef struct		s_holder
+{
+	int				count;
 	int				nb_state;
 	int				s_cmd;
 	int				s_pos;
+	int				error;
+	int				s_error;
+	int				state;
+	int				e_error;
+	int				v_error;
+	int				l_error;
+	int				gr_status;
 	int				s_vert;
 	int				e_vert;
-	int 			gr_status;
 	int				e_cmd;
 	int				e_pos;
 	int				v_flag;
-}					t_syntax;
+	t_temp			*data;
+}					t_holder;
 
-typedef struct 			s_adjnode
+typedef struct		s_rdata
 {
-	int					dest;
-	struct s_adjnode	*next;
-}						t_adjnode;
+	char			*line;
+	struct s_rdata	*next;
+}					t_rdata;
 
-typedef struct 			s_adjlist
+typedef	struct		s_lmdata
 {
-	t_adjnode			*head;
-}						t_adjlist;
-
-typedef struct 			s_graph
-{
-	int					vert;
-	t_adjlist			*array;
-}						t_graph;
-
-typedef struct 			s_neighbour
-{
-	int					vertnum;
-	struct s_neighbor	*next;
-}						t_neighbor;
-
-
-
-//MT-FUNCTIONS
-int                	lm_error_exit(int flag);
-int                 lm_parser(int fd, t_syntax *synt,
-					t_lmdata *ldata, t_graph *graph);
-void                lm_init_data(t_syntax *synt, t_lmdata *ldata);
-void                lm_add_vertex(t_lmdata *ldata, char *raw, char flag);
-t_adjnode           *lm_new_node(int dest);
-t_graph             *lm_creategraph(int v);
-void                lm_add_edge(t_graph *graph, int src, int dest);
-void                lm_ext_conn(t_graph *graph, t_lmdata *data, char *raw, t_syntax *synt);
-int                 lm_find_index(t_lmdata *data, char *str);
-
-
-
-
+	int				nbants;
+	int				nb_nodes;
+	int				nb_paths_max;
+	t_node			*nodes_data;
+	t_ind			**adj;
+	t_rdata			*map;
+}					t_lmdata;
 
+int					lm_parser(t_lmdata *ldata
+							, t_holder *holder);
+int					lm_check_room_before(char **tab, t_holder *holder
+							, char **name);
+void				lm_clear_unv(t_holder *holder);
+int					lm_add_vertex(t_lmdata *ldata, char *raw, char flag
+							, t_holder *holder);
+int					lm_ext_conn(t_holder *holder, t_lmdata *data
+							, char *raw);
+void				lm_ext_conn_sub(t_holder *holder, t_temp *new_data);
+int					lm_init_src_dest(int *src, int *dest, t_lmdata *data
+							, char *raw);
+int					lm_find_index(t_lmdata *data, char *str);
+void				lm_get_cmd_vertices(int count, t_holder *holder
+							, t_lmdata *ldata, char *line);
+int					lm_get_value(char *line);
+void				lm_check_start_vert(int count, t_holder *hol
+							, t_lmdata *ldata, char *line);
+void				lm_check_end_vert(int count, t_holder *hol
+							, t_lmdata *ldata, char *line);
+void				lm_get_vert_link(int count, t_lmdata *ldata
+							, t_holder *holder, char *line);
+int					lm_validate_rooms(char *name, char *x, char *y);
+int					lm_adj_parser(t_lmdata *lmdata, t_holder *holder);
+void				lm_init_data(t_holder *holder, t_lmdata *ldata);
+int					lm_verify_cmd(t_holder *holder, t_lmdata *data);
 void				lm_initdata(t_lmdata *data);
+int					lm_error_nbr(char *raw);
 int					lm_getparams(t_lmdata *data);
-
-
-
+void				lm_clean_data(t_lmdata *data);
+int					lm_check_forbiden_chars(char *line, int flag);
+t_ind				**lst_indinit(t_lmdata *data);
+int					lst_indadd_link(t_lmdata *data, int n1, int n2);
 t_ind				*lst_indadd(t_ind **lst, int ind);
 void				lst_inddel(t_ind **lst);
 void				tablst_inddel(t_ind **tab);
 
-void				bfs(t_lmdata *data, t_bfs *tab, int start_ind, int end_ind);
-t_ind				**edmunds_karp(t_lmdata *data, int start_ind, int end_ind);
+t_ants				*add_ant(t_ants	**ants, int nb_ant, int nb_path
+							, t_ind **paths);
+void				del_ants(t_ants **ants);
+t_node				*get_node(t_lmdata *data, int index);
+t_ind				*get_node_path(t_ind *lst, int index);
+
+void				bfs(t_lmdata *data, t_bfs *tab, int start_ind
+							, int end_ind);
+t_ind				**edmonds_karp(t_lmdata *data, int s_ind, int e_ind);
+int					get_score(t_lmdata *data, t_ind **ret, int nb_paths);
+void				print_paths(t_lmdata *data, t_ind **ret);
+int					push_ants(t_lmdata *data, t_ind **paths
+							, int nb_paths);
+void				push_ants_end(t_lmdata *data, char *e_name);
+
+void				del_map(t_lmdata *data);
+int					add_line_map(t_lmdata *data, char *line);
+void				print_map(t_lmdata *data);
+
+t_node				*get_node_role(t_lmdata *data, char role);
+int					get_nb_paths(t_ind **ret);
+void				get_nb_paths_max(t_lmdata *data, int start, int end);
 
 #endif

libft/Makefile

@@ -0,0 +1,166 @@
+#******************************************************************************#
+#                                                                              #
+#                                                         :::      ::::::::    #
+#    Makefile                                           :+:      :+:    :+:    #
+#                                                     +:+ +:+         +:+      #
+#    By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+         #
+#                                                 +#+#+#+#+#+   +#+            #
+#    Created: 2018/04/07 12:47:06 by tmaze             #+#    #+#              #
+#    Updated: 2019/05/09 18:39:42 by tmaze            ###   ########.fr        #
+#                                                                              #
+#******************************************************************************#
+
+CC = gcc
+CCFLAGS = -Wall -Werror -Wextra
+CCSTD =
+
+NAME = libft.a
+
+SRCS =	ft_memalloc.c	\
+		ft_memdel.c 	\
+		ft_memset.c		\
+		ft_bzero.c		\
+		ft_memcpy.c		\
+		ft_memccpy.c	\
+		ft_memmove.c	\
+		ft_memchr.c		\
+		ft_memcmp.c		\
+		\
+		ft_isalpha.c		\
+		ft_isdigit.c		\
+		ft_isalnum.c		\
+		ft_isascii.c		\
+		ft_isprint.c		\
+		ft_toupper.c		\
+		ft_isnumeric.c      \
+		ft_tolower.c		\
+		ft_isupper.c		\
+		ft_islower.c		\
+		ft_iswhitespace.c	\
+		ft_issign.c			\
+		\
+		ft_strnew.c 			\
+		ft_strdel.c 			\
+		ft_strclr.c				\
+		ft_striter.c			\
+		ft_striteri.c			\
+		ft_strmap.c				\
+		ft_strmapi.c 			\
+		ft_strequ.c				\
+		ft_strnequ.c			\
+		ft_strsub.c				\
+		ft_strjoin.c			\
+		ft_strtrim.c			\
+		ft_strsplit.c			\
+		ft_strlen.c				\
+		ft_strdup.c				\
+		ft_strcpy.c				\
+		ft_strncpy.c			\
+		ft_strcat.c				\
+		ft_strncat.c			\
+		ft_strlcat.c			\
+		ft_strchr.c				\
+		ft_strrchr.c			\
+		ft_strstr.c				\
+		ft_strnstr.c			\
+		ft_strcmp.c				\
+		ft_strncmp.c			\
+		ft_str_is_alpha.c		\
+		ft_str_is_lowercase.c	\
+		ft_str_is_numeric.c		\
+		ft_str_is_printable.c	\
+		ft_str_is_uppercase.c	\
+		ft_strcapitalize.c		\
+		ft_strlcpy.c			\
+		ft_strlowcase.c			\
+		ft_strupcase.c			\
+		ft_strndup.c			\
+		ft_strnchr.c			\
+		ft_strrnchr.c			\
+		ft_strsplitwhitespace.c	\
+		ft_hasdigit.c			\
+		ft_del_words_tables.c	\
+		\
+		ft_putchar.c			\
+		ft_putstr.c				\
+		ft_putendl.c			\
+		ft_putnbr.c				\
+		ft_putchar_fd.c			\
+		ft_putstr_fd.c			\
+		ft_putendl_fd.c			\
+		ft_putnbr_fd.c			\
+		ft_putstrpad.c			\
+		ft_putnbrpad.c			\
+		ft_putstrn.c 			\
+		ft_print_words_tables.c	\
+		ft_putendl2.c			\
+		ft_putendl_fd2.c		\
+		\
+		ft_lstnew.c		\
+		ft_lstdelone.c	\
+		ft_lstdel.c		\
+		ft_lstadd.c		\
+		ft_lstiter.c	\
+		ft_lstmap.c		\
+		ft_lstaddend.c	\
+		ft_lstsize.c	\
+		ft_lstgetat.c	\
+		ft_lstgetlast.c	\
+		ft_lstsort.c	\
+		ft_lstaddsort.c	\
+		\
+		ft_abs.c	\
+		ft_atoi.c	\
+		ft_atois.c	\
+		ft_itoa.c	\
+		ft_nbrlen.c	\
+		ft_round.c	\
+		\
+		ft_printf.c						\
+		ft_printf_check_fields.c		\
+		ft_printf_check_type.c			\
+		ft_printf_tools.c				\
+		ft_printf_tools_char.c			\
+		ft_printf_tools_float.c			\
+		ft_printf_tools_hexa.c			\
+		ft_printf_tools_int.c			\
+		ft_printf_tools_lenght.c 		\
+		ft_printf_tools_malloc_size.c 	\
+		ft_printf_tools_oct.c			\
+		ft_printf_tools_prec_size.c		\
+		ft_printf_tools_str.c			\
+		ft_printf_tools_unsigned_int.c	\
+		ft_printf_tools_wchar_t.c		\
+		ft_printf_tools_wstr.c			\
+		\
+		get_next_line.c	\
+		ft_getline.c	\
+		\
+		ft_sort_params.c	\
+		ft_realpath.c
+
+SRCDIR	= srcs
+OBJDIR	= objs
+OBJS	= $(SRCS:.c=.o)
+OBJP	= $(addprefix $(OBJDIR)/, $(OBJS))
+INCLS = -Iincludes
+
+.PHONY = all clean fclean re
+
+all: $(NAME)
+
+$(NAME): $(OBJP)
+	ar rcs $(NAME) $(OBJP)
+
+$(OBJDIR)/%.o: $(SRCDIR)/%.c includes/libft.h
+	@mkdir -p $(OBJDIR)
+	$(CC) $(CCFLAGS) $(CCSTD) $(INCLS) -c $< -o $@
+
+clean:
+	rm -f $(OBJP)
+
+fclean: clean
+	rm -f $(NAME)
+	rm -rf $(OBJDIR)	
+
+re: fclean all

libft/auteur

@@ -0,0 +1 @@
+tmaze

libft/includes/libft.h

@@ -0,0 +1,368 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   libft.h                                            :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/08 00:12:36 by tmaze             #+#    #+#             */
+/*   Updated: 2019/04/26 10:36:51 by mndhlovu         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef LIBFT_H
+# define LIBFT_H
+
+# include <string.h>
+# include <stdlib.h>
+# include <unistd.h>
+# include <stdarg.h>
+# include <limits.h>
+# include <stdint.h>
+# include <wchar.h>
+
+# define FT_RESET				"\x1b[0m"
+# define FT_BOLD				"\x1b[1m"
+# define FT_CLEAR				"\x1b[2J"
+
+# define FT_COLOR_BLACK			"\x1b[30m"
+# define FT_COLOR_RED			"\x1b[31m"
+# define FT_COLOR_GREEN			"\x1b[32m"
+# define FT_COLOR_YELLOW		"\x1b[33m"
+# define FT_COLOR_BLUE			"\x1b[34m"
+# define FT_COLOR_MAGENTA		"\x1b[35m"
+# define FT_COLOR_CYAN			"\x1b[36m"
+# define FT_COLOR_WHITE			"\x1b[37m"
+
+# define FT_COLOR_BG_BLACK		"\x1b[40m"
+# define FT_COLOR_BG_RED		"\x1b[41m"
+# define FT_COLOR_BG_GREEN		"\x1b[42m"
+# define FT_COLOR_BG_YELLOW		"\x1b[43m"
+# define FT_COLOR_BG_BLUE		"\x1b[44m"
+# define FT_COLOR_BG_MAGENTA	"\x1b[45m"
+# define FT_COLOR_BG_CYAN		"\x1b[46m"
+# define FT_COLOR_BG_WHITE		"\x1b[47m"
+
+# define FT_INT_MAX				2147483647
+# define FT_INT_MIN				-2147483648
+
+/*
+** définition type t_list
+*/
+
+typedef struct		s_list
+{
+	void			*content;
+	size_t			content_size;
+	struct s_list	*next;
+}					t_list;
+
+/*
+** definition macro BUFF_SIZE
+*/
+
+# define BUFF_SIZE 30
+
+/*
+** definition type t_file
+*/
+
+typedef struct		s_file
+{
+	int				fd;
+	char			buff[BUFF_SIZE + 1];
+}					t_file;
+
+enum				e_size
+{
+	h,
+	hh,
+	l,
+	ll,
+	j,
+	z,
+	L
+};
+
+enum				e_type
+{
+	p,
+	d,
+	i,
+	D,
+	o,
+	O,
+	u,
+	x,
+	X,
+	U,
+	s,
+	S,
+	c,
+	C,
+	percent,
+	f
+};
+
+typedef struct		s_conv
+{
+	int				fl_minus;
+	int				fl_plus;
+	int				fl_zero;
+	int				fl_hashtag;
+	int				fl_space;
+	int				fl_witdth;
+	int				fl_prec;
+	enum e_size		fl_size;
+	enum e_type		fl_type;
+	char			*str;
+	int				str_size;
+}					t_conv;
+
+/*
+** Print functions
+*/
+
+int					ft_printf(const char *format, ...);
+void				ft_putchar(char c);
+void				ft_putnbr(int n);
+void				ft_putstr(char const *s);
+
+/*
+** ft_printf tools
+*/
+
+void				init_struct_conv(t_conv *field);
+void				ft_align_str_zero(char *str, t_conv *field);
+void				ft_align_str(char *str, t_conv *field);
+void				set_malloc_sizes(uintmax_t nb, t_conv *field);
+void				set_malloc_sizeu(uintmax_t nb, t_conv *field);
+void				set_malloc_sizeo(uintmax_t nb, t_conv *field);
+void				set_malloc_sizeu(uintmax_t nb, t_conv *field);
+int					set_malloc_sizef(long double nb, char *nbrstr
+									, t_conv *field);
+void				init_handler_tab(char *(*f[14])(t_conv *, va_list));
+int					ft_wstrlen(const wint_t *str);
+uint64_t			dmod(long double nb, long double mod);
+
+/*
+** Check Flags
+*/
+
+void				check_flags(const char **str, t_conv *field);
+void				check_width(const char **str, t_conv *field, va_list ap);
+ssize_t				check_precision(const char **str, t_conv *field
+									, va_list ap);
+void				check_size(const char **str, t_conv *field);
+ssize_t				check_type_one(const char **str, t_conv *field);
+ssize_t				check_type_two(const char **str, t_conv *field);
+ssize_t				check_fields(const char **str, va_list ap, t_conv *field);
+
+/*
+** Handle type i and d
+*/
+
+char				*handler_int(uintmax_t nb, t_conv *field);
+char				*select_int_handler(t_conv *field, va_list ap);
+char				*handle_output_i_d(t_conv *field, va_list ap);
+
+/*
+** Handle type u
+*/
+
+char				*select_uns_int_handler(t_conv *field, va_list ap);
+char				*handle_output_u(t_conv *field, va_list ap);
+char				*handler_uns(uintmax_t nb, t_conv *field);
+
+/*
+** Handle type x and X
+*/
+
+char				*handler_hexa(uintmax_t nb, t_conv *field);
+char				*select_hexa_handler(t_conv *field, va_list ap);
+char				*handle_output_hexa(t_conv *field, va_list ap);
+void				ft_align_hex_zero(char *str, t_conv *field);
+void				ft_align_hex(char *str, t_conv *field);
+int					set_precision_sizex(uintmax_t nb, t_conv *field);
+void				set_malloc_sizeh(uintmax_t nb, t_conv *field);
+
+/*
+** Handle type o
+*/
+
+char				*handler_oct(uintmax_t nb, t_conv *field);
+char				*select_oct_handler(t_conv *field, va_list ap);
+char				*handle_output_oct(t_conv *field, va_list ap);
+void				ft_align_oct_zero(char *str, t_conv *field);
+void				ft_align_oct(char *str, t_conv *field);
+int					set_precision_sizeo(uintmax_t nb, t_conv *field);
+
+/*
+** Handle type c
+*/
+
+char				*handle_output_char(t_conv *field, va_list ap);
+
+/*
+** Handle type C
+*/
+
+unsigned int		ft_bin_size(unsigned int nb);
+void				ft_align_wchar(char *str, t_conv *field);
+char				*handler_2oct_char(wint_t c, t_conv *field);
+char				*handler_3oct_char(wint_t c, t_conv *field);
+char				*handler_4oct_char(wint_t c, t_conv *field);
+char				*handle_output_wchar(t_conv *field, va_list ap);
+
+/*
+** Handle type s
+*/
+
+char				*handle_output_str(t_conv *field, va_list ap);
+void				ft_align_wstr(char *str, t_conv *field);
+int					set_precision_sizes(uintmax_t nb, t_conv *field);
+
+/*
+** Handle type S
+*/
+
+char				*handle_output_wstr(t_conv *field, va_list ap);
+int					set_prec_size_wstr(const wint_t *str, t_conv *field);
+
+/*
+** Handle type f
+*/
+
+char				*handle_output_float(t_conv *field, va_list ap);
+
+/*
+** fonctions obligatoires
+*/
+
+void				*ft_memset(void *b, int c, size_t len);
+void				ft_bzero(void *s, size_t n);
+void				*ft_memcpy(void *dest, const void *src,\
+								size_t n);
+void				*ft_memccpy(void *dest, const void *src,\
+								int c, size_t n);
+void				*ft_memmove(void *dest, const void *src, size_t len);
+void				*ft_memchr(const void *s, int c, size_t n);
+int					ft_memcmp(const void *s1, const void *s2, size_t n);
+size_t				ft_strlen(const char *s);
+char				*ft_strdup(const char *s);
+char				*ft_strcpy(char *dest, const char *src);
+char				*ft_strncpy(char *dest, const char *src, size_t n);
+char				*ft_strcat(char *dest, const char *src);
+char				*ft_strncat(char *dest, const char *src,\
+								size_t n);
+size_t				ft_strlcat(char *dst, const char *src, size_t size);
+char				*ft_strchr(const char *s, int c);
+char				*ft_strrchr(const char *s, int c);
+char				*ft_strstr(const char *haystack, const char *needle);
+char				*ft_strnstr(const char *haystack, const char *needle,\
+								size_t len);
+int					ft_strcmp(const char *s1, const char *s2);
+int					ft_strncmp(const char *s1, const char *s2, size_t n);
+int					ft_atoi(const char *str);
+int					ft_isalpha(int c);
+int					ft_isdigit(int c);
+int					ft_isnumeric(char *str);
+int					ft_isalnum(int c);
+int					ft_isascii(int c);
+int					ft_isprint(int c);
+int					ft_toupper(int c);
+int					ft_tolower(int c);
+
+/*
+** fonctions supplémentaires
+*/
+
+void				*ft_memalloc(size_t size);
+void				ft_memdel(void **ap);
+char				*ft_strnew(size_t size);
+void				ft_strdel(char **as);
+void				ft_strclr(char *s);
+void				ft_striter(char *s, void (*f)(char *));
+void				ft_striteri(char *s, void (*f)(unsigned int, char *));
+char				*ft_strmap(char const *s, char (*f)(char));
+char				*ft_strmapi(char const *s, char (*f)(unsigned int, char));
+int					ft_strequ(char const *s1, char const *s2);
+int					ft_strnequ(char const *s1, char const *s2, size_t n);
+char				*ft_strsub(char const *s, unsigned int start, size_t len);
+char				*ft_strjoin(char const *s1, char const *s2);
+char				*ft_strtrim(char const *s);
+char				**ft_strsplit(char const *s, char c);
+char				*ft_itoa(int n);
+void				ft_putchar(char c);
+void				ft_putstr(char const *s);
+void				ft_putendl(char const *s);
+void				ft_putnbr(int n);
+void				ft_putchar_fd(char c, int fd);
+void				ft_putstr_fd(char const *s, int fd);
+void				ft_putendl_fd(char const *s, int fd);
+void				ft_putnbr_fd(int n, int fd);
+
+/*
+** fonctions bonus
+*/
+
+t_list				*ft_lstnew(void const *content, size_t content_size);
+void				ft_lstdelone(t_list **alst, void (*del)(void *, size_t));
+void				ft_lstdel(t_list **alst, void (*del)(void *, size_t));
+void				ft_lstadd(t_list **alst, t_list *new);
+void				ft_lstiter(t_list *lst, void (*f)(t_list *elem));
+t_list				*ft_lstmap(t_list *lst, t_list *(*f)(t_list *elem));
+
+/*
+** fonctions additionneles
+*/
+
+int					ft_isupper(int c);
+int					ft_islower(int c);
+int					ft_str_is_alpha(char *str);
+int					ft_str_is_lowercase(char *str);
+int					ft_str_is_numeric(char *str);
+int					ft_str_is_printable(char *str);
+int					ft_str_is_uppercase(char *str);
+char				*ft_strlowcase(char *s);
+char				*ft_strupcase(char *s);
+char				*ft_strcapitalize(char *str);
+size_t				ft_strlcpy(char	*dst, const char *src,\
+								size_t size);
+size_t				ft_lstsize(t_list *lst);
+t_list				*ft_lstgetat(t_list *lst, size_t ind);
+t_list				*ft_lstgetlast(t_list *lst);
+void				ft_sort_params(int ac, char **av);
+void				ft_print_words_tables(char **tab);
+t_list				*ft_lstaddend(t_list **alst, t_list *new);
+char				*ft_strndup(const char *s1, size_t n);
+unsigned int		ft_abs(int nb);
+char				*ft_strnchr(const char *s, int c, int n);
+char				*ft_strrnchr(const char *s, int c, int n);
+
+int					get_next_line(const int fd, char **line);
+
+void				ft_del_words_tables(char ***word_table);
+void				ft_putstrn(char	const *s, size_t nb);
+size_t				ft_nbrlen(int nb);
+void				ft_putstrpad(char *str, size_t size, char pad, char align);
+void				ft_putnbrpad(int nbr, size_t size, char pad, char align);
+
+void				ft_lstsort(t_list **lst, int (*f)(void *c1, void *c2),
+								int rev);
+void				ft_lstaddsort(t_list **lst, t_list *new,
+								int (*f)(void *c1, void *c2), int rev);
+
+int					ft_round(float x, float ind);
+
+char				*ft_realpath(char *r_path, char **a_path);
+int					ft_issign(char c);
+int					ft_iswhitespace(char c);
+int					ft_hasdigit(char *s);
+char				**ft_strsplitwhitespace(char *s);
+int					ft_atois(const char *str, int *nb);
+int					ft_getline(char **line);
+int					ft_putendl2(char const *s);
+int					ft_putendl_fd2(char const *s, int fd);
+
+#endif

libft/srcs/ft_abs.c

@@ -0,0 +1,20 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_abs.c                                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/05/05 16:44:52 by tmaze             #+#    #+#             */
+/*   Updated: 2018/05/05 16:49:04 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+unsigned int	ft_abs(int nb)
+{
+	if (nb < 0)
+		return (nb * -1);
+	return (nb);
+}

libft/srcs/ft_atoi.c

@@ -0,0 +1,40 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_atoi.c                                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/05 13:50:22 by tmaze             #+#    #+#             */
+/*   Updated: 2019/03/16 15:37:42 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int		ft_atoi(const char *str)
+{
+	int	nbnum;
+	int	mult;
+	int ret;
+
+	nbnum = 0;
+	while (str[nbnum] == ' ' || str[nbnum] == '\t' || str[nbnum] == '\n'
+			|| str[nbnum] == '\v' || str[nbnum] == '\f' || str[nbnum] == '\r')
+		nbnum++;
+	if (str[nbnum] == '+' || str[nbnum] == '-')
+		nbnum++;
+	while (str[nbnum] != '\0' && ft_isdigit(str[nbnum]))
+		nbnum++;
+	nbnum--;
+	ret = 0;
+	mult = 1;
+	while (nbnum >= 0 && ft_isdigit(str[nbnum]))
+	{
+		ret += (str[nbnum--] - '0') * mult;
+		mult *= 10;
+	}
+	if (nbnum >= 0 && str[nbnum] == '-')
+		ret *= -1;
+	return (ret);
+}

libft/srcs/ft_atois.c

@@ -0,0 +1,41 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_atois.c                                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/02/27 11:58:44 by tmaze             #+#    #+#             */
+/*   Updated: 2019/03/16 15:47:50 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int	ft_atois(const char *str, int *nb)
+{
+	int	num;
+	int	mult;
+	int	max;
+
+	num = 0;
+	while (ft_iswhitespace(str[num]))
+		num++;
+	max = (str[num] == '-') ? FT_INT_MIN : FT_INT_MAX;
+	if (str[num] == '+' || str[num] == '-')
+		num++;
+	while (str[num] != '\0' && ft_isdigit(str[num]))
+		num++;
+	num--;
+	*nb = 0;
+	mult = 1;
+	while (num >= 0 && ft_isdigit(str[num])
+			&& (ft_abs(max - *nb) >= 2000000000))
+	{
+		*nb += (str[num--] - '0') * mult;
+		mult *= 10;
+	}
+	if (num >= 0 && str[num] == '-')
+		*nb *= -1;
+	return (!ft_isdigit(str[num]) || ft_abs(max - *nb) >= 2000000000);
+}

libft/srcs/ft_bzero.c

@@ -0,0 +1,18 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_bzero.c                                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/05 16:43:09 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/06 10:49:12 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_bzero(void *s, size_t n)
+{
+	ft_memset(s, 0, n);
+}

libft/srcs/ft_close.c

@@ -0,0 +1,22 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_close.c                                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/03/08 13:39:05 by tmaze             #+#    #+#             */
+/*   Updated: 2019/03/08 13:44:25 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int	ft_close(t_file *file)
+{
+	int filedes;
+
+	filedes = file->fd;
+	ft_memdel(file);
+	return (close(filedes) == 0);
+}

libft/srcs/ft_del_words_tables.c

@@ -0,0 +1,24 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_del_words_tables.c                              :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/07/25 15:13:09 by tmaze             #+#    #+#             */
+/*   Updated: 2018/07/25 16:03:19 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_del_words_tables(char ***word_table)
+{
+	int	i;
+
+	i = -1;
+	while ((*word_table)[++i])
+		ft_strdel(&(*word_table)[i]);
+	ft_memdel((void**)word_table);
+	*word_table = NULL;
+}

libft/srcs/ft_getline.c

@@ -0,0 +1,87 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_getline.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/03/07 15:12:59 by tmaze             #+#    #+#             */
+/*   Updated: 2019/03/19 17:30:24 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+static int	get_last_ind(char *buff)
+{
+	int		i;
+
+	i = 0;
+	while (buff[i] && buff[i] != '\n')
+		i++;
+	return (i);
+}
+
+static int	flush_buff(char **line, char *buff)
+{
+	char	*tmp;
+	int		i;
+
+	i = get_last_ind(buff);
+	if (*line == NULL)
+	{
+		if ((*line = ft_strndup(buff, i)) == NULL)
+			return (-1);
+	}
+	else if (*line != NULL)
+	{
+		if ((tmp = ft_strnew(ft_strlen(*line) + i)) != NULL)
+		{
+			ft_strcpy(tmp, *line);
+			ft_strncat(tmp, buff, i);
+			ft_strdel(line);
+			*line = tmp;
+		}
+		else
+		{
+			ft_strdel(line);
+			return (-1);
+		}
+	}
+	return (i);
+}
+
+static void	init_getline(char **line, int *check, int *ret)
+{
+	*line = NULL;
+	*check = BUFF_SIZE;
+	*ret = -2;
+}
+
+int			ft_getline(char **line)
+{
+	static char	buff[BUFF_SIZE] = "\0";
+	int			check;
+	int			ret;
+	int			i;
+
+	if (line == NULL || BUFF_SIZE < 1)
+		return (-1);
+	init_getline(line, &check, &ret);
+	while (check == BUFF_SIZE)
+	{
+		if (buff[0] == '\0')
+		{
+			if ((ret = read(0, buff, BUFF_SIZE)) == -1)
+				return (-1);
+			if (ret == 0 && *line == NULL)
+				return (0);
+		}
+		if ((i = flush_buff(line, buff)) == -1)
+			return (-1);
+		check = (buff[i] != '\n' && ret != 0) ? BUFF_SIZE : i;
+		ft_memmove(buff, buff + i + 1, BUFF_SIZE - i);
+		ft_memset(buff + BUFF_SIZE - i, '\0', i);
+	}
+	return (1);
+}

libft/srcs/ft_gets.c

@@ -0,0 +1,13 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_gets.c                                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/03/08 13:44:31 by tmaze             #+#    #+#             */
+/*   Updated: 2019/03/16 15:33:26 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"

libft/srcs/ft_hasdigit.c

@@ -0,0 +1,23 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_hasdigit.c                                      :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/02/25 16:16:40 by tmaze             #+#    #+#             */
+/*   Updated: 2019/02/28 16:18:26 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int	ft_hasdigit(char *s)
+{
+	int	i;
+
+	i = 0;
+	while (s[i] && !ft_isdigit(s[i]))
+		i++;
+	return (ft_isdigit(s[i]));
+}

libft/srcs/ft_isalnum.c

@@ -0,0 +1,18 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_isalnum.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/04 11:51:53 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/04 12:00:08 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int	ft_isalnum(int c)
+{
+	return (ft_isalpha(c) || ft_isdigit(c));
+}

libft/srcs/ft_isalpha.c

@@ -0,0 +1,18 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_isalpha.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/04 10:56:47 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/09 10:21:34 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int	ft_isalpha(int c)
+{
+	return (ft_islower(c) || ft_isupper(c));
+}

libft/srcs/ft_isascii.c

@@ -0,0 +1,18 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_isascii.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/04 12:23:59 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/04 12:25:37 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int	ft_isascii(int c)
+{
+	return (c >= 0 && c <= 127);
+}

libft/srcs/ft_isdigit.c

@@ -0,0 +1,18 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_isdigit.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/04 11:33:35 by tmaze             #+#    #+#             */
+/*   Updated: 2019/04/29 11:16:40 by mndhlovu         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int		ft_isdigit(int c)
+{
+	return (c >= '0' && c <= '9');
+}

libft/srcs/ft_islower.c

@@ -0,0 +1,18 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_islower.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/09 10:20:43 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/09 10:21:23 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int	ft_islower(int c)
+{
+	return (c >= 'a' && c <= 'z');
+}

libft/srcs/ft_isnumeric.c

@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_isnumeric.c                                     :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: mndhlovu <mndhlovu@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/04/26 10:17:04 by mndhlovu          #+#    #+#             */
+/*   Updated: 2019/04/29 11:20:54 by mndhlovu         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int					ft_isnumeric(char *str)
+{
+	int				index;
+
+	index = 0;
+	if (str[index] == '-' || str[index] == '+')
+		index++;
+	while (str[index] != '\0')
+	{
+		if (!ft_isdigit(str[index]))
+			return (0);
+		index++;
+	}
+	return (1);
+}

libft/srcs/ft_isprint.c

@@ -0,0 +1,18 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_isprint.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/04 12:29:36 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/04 12:30:28 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int	ft_isprint(int c)
+{
+	return (c >= 32 && c <= 126);
+}

libft/srcs/ft_issign.c

@@ -0,0 +1,18 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_issign.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/02/25 16:18:54 by tmaze             #+#    #+#             */
+/*   Updated: 2019/02/25 16:19:13 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int	ft_issign(char c)
+{
+	return (c == '+' || c == '-');
+}

libft/srcs/ft_isupper.c

@@ -0,0 +1,18 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_isupper.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/09 10:10:12 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/09 10:10:31 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int	ft_isupper(int c)
+{
+	return (c >= 'A' && c <= 'Z');
+}

libft/srcs/ft_iswhitespace.c

@@ -0,0 +1,19 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_iswhitespace.c                                  :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/02/25 16:11:19 by tmaze             #+#    #+#             */
+/*   Updated: 2019/02/25 16:13:25 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int	ft_iswhitespace(char c)
+{
+	return (c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f'
+			|| c == '\r');
+}

libft/srcs/ft_itoa.c

@@ -0,0 +1,41 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_itoa.c                                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/08 11:20:12 by tmaze             #+#    #+#             */
+/*   Updated: 2018/05/05 16:48:49 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+char					*ft_itoa(int n)
+{
+	unsigned long	mult;
+	int				nb_nbr;
+	int				sign;
+	unsigned long	nbr;
+	char			*ret;
+
+	mult = 10;
+	nb_nbr = 1;
+	nbr = ft_abs(n);
+	sign = (n < 0);
+	while (mult <= nbr && (nb_nbr++))
+		mult *= 10;
+	nb_nbr += sign;
+	if ((ret = ft_strnew(nb_nbr)) == NULL)
+		return (NULL);
+	nb_nbr = 0;
+	if (sign && (++nb_nbr))
+		ret[0] = '-';
+	while (mult > 1)
+	{
+		ret[nb_nbr++] = '0' + ((nbr % mult) / (mult / 10));
+		mult /= 10;
+	}
+	return (ret);
+}

libft/srcs/ft_lstadd.c

@@ -0,0 +1,19 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_lstadd.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/08 19:26:05 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/08 19:27:35 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_lstadd(t_list **alst, t_list *new)
+{
+	new->next = *alst;
+	*alst = new;
+}

libft/srcs/ft_lstaddend.c

@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_lstaddend.c                                     :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/17 20:55:26 by tmaze             #+#    #+#             */
+/*   Updated: 2018/11/26 12:30:30 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+t_list	*ft_lstaddend(t_list **alst, t_list *new)
+{
+	t_list *tmp;
+
+	if (new == NULL)
+		return (NULL);
+	if (ft_lstsize(*alst) == 0)
+		ft_lstadd(alst, new);
+	else if (ft_lstsize(*alst) > 0)
+	{
+		tmp = ft_lstgetlast(*alst);
+		ft_lstadd(&(tmp->next), new);
+	}
+	return (*alst);
+}

libft/srcs/ft_lstaddsort.c

@@ -0,0 +1,31 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_lstaddsort.c                                    :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/10/01 11:57:25 by tmaze             #+#    #+#             */
+/*   Updated: 2018/10/02 16:43:09 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_lstaddsort(t_list **lst, t_list *new, int (*f)(void *c1, void *c2),
+						int rev)
+{
+	t_list	**sort;
+
+	sort = lst;
+	if (*lst == NULL || (!rev && (*f)((*lst)->content, new->content) > 0)
+		|| (rev && (*f)((*lst)->content, new->content) < 0))
+		ft_lstadd(lst, new);
+	else
+	{
+		while ((*sort) && ((rev && (*f)((*sort)->content, new->content) >= 0)
+					|| (!rev && (*f)((*sort)->content, new->content) <= 0)))
+			sort = &(*sort)->next;
+		ft_lstadd(&(*sort), new);
+	}
+}

libft/srcs/ft_lstdel.c

@@ -0,0 +1,23 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_lstdel.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/08 17:19:32 by tmaze             #+#    #+#             */
+/*   Updated: 2018/06/12 00:33:45 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_lstdel(t_list **alst, void (*del)(void*, size_t))
+{
+	if (*alst)
+	{
+		if ((*alst)->next != NULL)
+			ft_lstdel(&((*alst)->next), del);
+		ft_lstdelone(alst, del);
+	}
+}

libft/srcs/ft_lstdelone.c

@@ -0,0 +1,20 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_lstdelone.c                                     :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/08 17:00:17 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/08 17:22:15 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_lstdelone(t_list **alst, void (*del)(void*, size_t))
+{
+	(*del)((*alst)->content, (*alst)->content_size);
+	free(*alst);
+	*alst = NULL;
+}

libft/srcs/ft_lstgetat.c

@@ -0,0 +1,28 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_lstgetat.c                                      :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/09 16:35:51 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/09 16:45:36 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+t_list	*ft_lstgetat(t_list *lst, size_t ind)
+{
+	size_t	i;
+	t_list	*tmp;
+
+	i = 0;
+	tmp = lst;
+	while (i != ind && tmp)
+	{
+		i++;
+		tmp = tmp->next;
+	}
+	return (tmp);
+}

libft/srcs/ft_lstgetlast.c

@@ -0,0 +1,18 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_lstgetlast.c                                    :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/09 17:34:10 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/12 12:23:02 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+t_list	*ft_lstgetlast(t_list *lst)
+{
+	return (ft_lstgetat(lst, ft_lstsize(lst) - 1));
+}

libft/srcs/ft_lstiter.c

@@ -0,0 +1,25 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_lstiter.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/08 19:48:44 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/08 19:51:33 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_lstiter(t_list *lst, void (*f)(t_list *elem))
+{
+	t_list	*tmp;
+
+	tmp = lst;
+	while (tmp)
+	{
+		(*f)(tmp);
+		tmp = tmp->next;
+	}
+}

libft/srcs/ft_lstmap.c

@@ -0,0 +1,37 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_lstmap.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/08 19:54:31 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/10 14:31:03 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+static void	ft_lstdelmem(void *content, size_t content_size)
+{
+	(void)content_size;
+	free(content);
+}
+
+t_list		*ft_lstmap(t_list *lst, t_list *(*f)(t_list *elem))
+{
+	t_list	*ret;
+	t_list	*new;
+
+	ret = NULL;
+	if (lst != NULL && f != NULL)
+	{
+		if (lst->next != NULL)
+			ret = ft_lstmap(lst->next, f);
+		if ((new = (*f)(lst)) == NULL)
+			ft_lstdel(&ret, &ft_lstdelmem);
+		else
+			ft_lstadd(&ret, new);
+	}
+	return (ret);
+}

libft/srcs/ft_lstnew.c

@@ -0,0 +1,39 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_lstnew.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/08 00:35:42 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/08 17:15:34 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+t_list	*ft_lstnew(void const *content, size_t content_size)
+{
+	t_list	*ret;
+
+	if ((ret = (t_list*)malloc(sizeof(t_list))) != NULL)
+	{
+		if (!content)
+		{
+			ret->content = NULL;
+			ret->content_size = 0;
+		}
+		else
+		{
+			if ((ret->content = malloc(content_size)) == NULL)
+			{
+				free(ret);
+				return (0);
+			}
+			ft_memmove(ret->content, content, content_size);
+			ret->content_size = content_size;
+		}
+		ret->next = NULL;
+	}
+	return (ret);
+}

libft/srcs/ft_lstsize.c

@@ -0,0 +1,21 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_lstsize.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/09 13:55:29 by tmaze             #+#    #+#             */
+/*   Updated: 2018/11/28 14:46:12 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+size_t	ft_lstsize(t_list *lst)
+{
+	if (lst == NULL)
+		return (0);
+	else
+		return (ft_lstsize(lst->next) + 1);
+}

libft/srcs/ft_lstsort.c

@@ -0,0 +1,30 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_lstsort.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/10/01 11:54:22 by tmaze             #+#    #+#             */
+/*   Updated: 2018/10/01 12:42:27 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_lstsort(t_list **lst, int (*f)(void *c1, void *c2), int rev)
+{
+	t_list	*sorted;
+	t_list	*ind;
+	t_list	*next;
+
+	ind = *lst;
+	sorted = NULL;
+	while (ind)
+	{
+		next = ind->next;
+		ft_lstaddsort(&sorted, ind, (*f), rev);
+		ind = next;
+	}
+	*lst = sorted;
+}

libft/srcs/ft_memalloc.c

@@ -0,0 +1,22 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_memalloc.c                                      :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/06 17:38:56 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/06 18:07:20 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	*ft_memalloc(size_t size)
+{
+	void	*ret;
+
+	if ((ret = malloc(size)) != NULL)
+		ft_bzero(ret, size);
+	return (ret);
+}

libft/srcs/ft_memccpy.c

@@ -0,0 +1,27 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_memccpy.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/06 11:29:28 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/06 11:30:21 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	*ft_memccpy(void *dest, const void *src, int c, size_t n)
+{
+	size_t i;
+
+	i = 0;
+	while (++i <= n)
+	{
+		((char*)dest)[i - 1] = ((char*)src)[i - 1];
+		if (((unsigned char*)src)[i - 1] == (unsigned char)c)
+			return (dest + i);
+	}
+	return (NULL);
+}

libft/srcs/ft_memchr.c

@@ -0,0 +1,26 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_memchr.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/06 16:07:52 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/06 16:27:54 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	*ft_memchr(const void *s, int c, size_t n)
+{
+	int		i;
+	char	*tmp;
+
+	i = -1;
+	tmp = (char*)s;
+	while ((unsigned int)++i < n)
+		if ((char)tmp[i] == (char)c)
+			return ((void*)&tmp[i]);
+	return (NULL);
+}

libft/srcs/ft_memcmp.c

@@ -0,0 +1,31 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_memcmp.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/06 16:55:25 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/08 13:41:54 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int	ft_memcmp(const void *s1, const void *s2, size_t n)
+{
+	size_t	i;
+	int		diff;
+	void	*str1;
+	void	*str2;
+
+	i = 0;
+	diff = 0;
+	str1 = (void*)s1;
+	str2 = (void*)s2;
+	if (n > 0)
+		diff = ((unsigned char*)str1)[0] - ((unsigned char*)str2)[0];
+	while (diff == 0 && ++i < n)
+		diff = ((unsigned char*)str1)[i] - ((unsigned char*)str2)[i];
+	return (diff);
+}

libft/srcs/ft_memcpy.c

@@ -0,0 +1,23 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_memcpy.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/06 11:05:36 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/06 11:09:57 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	*ft_memcpy(void *dest, const void *src, size_t n)
+{
+	size_t i;
+
+	i = 0;
+	while (++i <= n)
+		((char*)dest)[i - 1] = ((char*)src)[i - 1];
+	return (dest);
+}

libft/srcs/ft_memdel.c

@@ -0,0 +1,22 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_memdel.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/06 18:21:08 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/07 15:27:28 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_memdel(void **ap)
+{
+	if (ap && *ap)
+	{
+		free(*ap);
+		*ap = NULL;
+	}
+}

libft/srcs/ft_memmove.c

@@ -0,0 +1,30 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_memmove.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/06 15:06:49 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/08 13:28:55 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	*ft_memmove(void *dst, const void *src, size_t len)
+{
+	size_t i;
+
+	i = 0;
+	if (src < dst)
+	{
+		i = len + 1;
+		while (--i > 0)
+			((char*)dst)[i - 1] = ((char*)src)[i - 1];
+	}
+	else if (src > dst)
+		while (++i <= len)
+			((char*)dst)[i - 1] = ((char*)src)[i - 1];
+	return (dst);
+}

libft/srcs/ft_memset.c

@@ -0,0 +1,23 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_memset.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/05 15:22:55 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/06 18:20:06 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	*ft_memset(void *b, int c, size_t len)
+{
+	size_t	i;
+
+	i = 0;
+	while (i < len)
+		((char*)b)[i++] = c;
+	return (b);
+}

libft/srcs/ft_nbrlen.c

@@ -0,0 +1,30 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_nbrlen.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/07/25 17:45:29 by tmaze             #+#    #+#             */
+/*   Updated: 2018/07/25 18:20:22 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+size_t	ft_nbrlen(int nb)
+{
+	size_t	nb_len;
+
+	nb_len = 0;
+	if (nb <= 0)
+		nb_len++;
+	if (nb < 0)
+		nb *= -1;
+	while (nb > 0)
+	{
+		nb /= 10;
+		nb_len++;
+	}
+	return (nb_len);
+}

libft/srcs/ft_open.c

@@ -0,0 +1,28 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_open.c                                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/03/08 13:27:26 by tmaze             #+#    #+#             */
+/*   Updated: 2019/03/08 13:38:29 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+t_file	*ft_open(char *filename, oint oflag)
+{
+	t_file *ret;
+
+	if ((ret = ft_memalloc(sizeof(t_file))) == NULL)
+		return (NULL);
+	if ((ret->fd = open(filename, oflag)) == -1)
+	{
+		ft_memdel(&ret);
+		return (NULL);
+	}
+	ft_bzero(ret->buff, BUFF_SIZE + 1);
+	return (ret);
+}

libft/srcs/ft_print_words_tables.c

@@ -0,0 +1,25 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_print_words_tables.c                            :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/15 15:48:16 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/21 15:47:57 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_print_words_tables(char **tab)
+{
+	unsigned int	i;
+
+	i = 0;
+	while (tab[i])
+	{
+		ft_putendl(tab[i]);
+		i++;
+	}
+}

libft/srcs/ft_printf.c

@@ -0,0 +1,91 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_printf.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: klebon <klebon@student.42.fr>              +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/28 22:27:58 by klebon            #+#    #+#             */
+/*   Updated: 2019/03/07 22:16:43 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	init_handler_tab(char *(*t[16])(t_conv *, va_list))
+{
+	t[d] = &handle_output_i_d;
+	t[D] = &handle_output_i_d;
+	t[i] = &handle_output_i_d;
+	t[x] = &handle_output_hexa;
+	t[X] = &handle_output_hexa;
+	t[p] = &handle_output_hexa;
+	t[o] = &handle_output_oct;
+	t[O] = &handle_output_oct;
+	t[u] = handle_output_u;
+	t[U] = handle_output_u;
+	t[c] = &handle_output_char;
+	t[C] = &handle_output_wchar;
+	t[s] = &handle_output_str;
+	t[S] = &handle_output_wstr;
+	t[percent] = &handle_output_char;
+	t[f] = &handle_output_float;
+}
+
+void	clean_mem(t_conv *field, va_list ap)
+{
+	free(field);
+	va_end(ap);
+}
+
+int		handle_conv(const char **str, t_conv *field, va_list ap, int *nb_print)
+{
+	char		*(*handler[16])(t_conv *, va_list);
+
+	init_handler_tab(handler);
+	(*str)++;
+	if (check_fields(str, ap, field))
+	{
+		if (!(field->str = handler[field->fl_type](field, ap)))
+		{
+			clean_mem(field, ap);
+			return (0);
+		}
+		write(1, field->str, field->str_size);
+		*nb_print += field->str_size;
+		free(field->str);
+	}
+	else
+	{
+		clean_mem(field, ap);
+		return (0);
+	}
+	return (1);
+}
+
+int		ft_printf(const char *format, ...)
+{
+	va_list		ap;
+	const char	*str;
+	int			nb_print_chars;
+	t_conv		*field;
+
+	if (!(field = (t_conv *)malloc(sizeof(t_conv))))
+		return (-1);
+	va_start(ap, format);
+	str = format;
+	nb_print_chars = 0;
+	while (str && *str)
+	{
+		if (*str != '%')
+		{
+			write(1, str, 1);
+			++nb_print_chars;
+		}
+		else if (!(handle_conv(&str, field, ap, &nb_print_chars)))
+			return (-1);
+		++str;
+	}
+	clean_mem(field, ap);
+	return (nb_print_chars);
+}

libft/srcs/ft_printf_check_fields.c

@@ -0,0 +1,142 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   check_fields.c                                     :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: klebon <klebon@student.42.fr>              +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/29 12:33:40 by klebon            #+#    #+#             */
+/*   Updated: 2019/03/07 22:16:54 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	check_flags(const char **str, t_conv *field)
+{
+	while (**str == '-' || **str == '+' || **str == '0' || **str == '#'
+			|| **str == ' ')
+	{
+		if (**str == '-')
+			field->fl_minus = 1;
+		else if (**str == '+')
+			field->fl_plus = 1;
+		else if (**str == '0')
+			field->fl_zero = 1;
+		else if (**str == '#')
+			field->fl_hashtag = 1;
+		else if (**str == ' ')
+			field->fl_space = 1;
+		(*str)++;
+	}
+}
+
+void	check_width(const char **str, t_conv *field, va_list ap)
+{
+	int	tmp;
+
+	if (**str == '*')
+	{
+		tmp = va_arg(ap, int);
+		field->fl_witdth = (tmp < 0) ? -tmp : tmp;
+		if (tmp < 0)
+			field->fl_minus = 1;
+		(*str)++;
+	}
+	else
+	{
+		field->fl_witdth = 0;
+		while (**str >= '0' && **str <= '9')
+		{
+			field->fl_witdth *= 10;
+			field->fl_witdth += **str - '0';
+			(*str)++;
+		}
+	}
+}
+
+ssize_t	check_precision(const char **str, t_conv *field, va_list ap)
+{
+	int	tmp;
+
+	if (**str == '.')
+	{
+		(*str)++;
+		if (**str == '*')
+		{
+			if ((tmp = va_arg(ap, int)) >= 0)
+				field->fl_prec = tmp;
+			(*str)++;
+		}
+		else if (**str >= '0' && **str <= '9')
+		{
+			field->fl_prec = 0;
+			while (**str >= '0' && **str <= '9')
+			{
+				field->fl_prec *= 10;
+				field->fl_prec += **str - '0';
+				(*str)++;
+			}
+		}
+		else
+			field->fl_prec = 0;
+	}
+	return (1);
+}
+
+void	check_size(const char **str, t_conv *field)
+{
+	if (**str == 'h' || **str == 'l' || **str == 'j' || **str == 'z'
+		|| **str == 'L')
+	{
+		if (**str == 'h' && *(*str + 1) == 'h')
+		{
+			field->fl_size = hh;
+			(*str)++;
+		}
+		else if (**str == 'h')
+			field->fl_size = h;
+		else if (**str == 'l' && *(*str + 1) == 'l')
+		{
+			field->fl_size = ll;
+			(*str)++;
+		}
+		else if (**str == 'l')
+			field->fl_size = l;
+		else if (**str == 'j')
+			field->fl_size = l;
+		else if (**str == 'z')
+			field->fl_size = l;
+		else if (**str == 'L')
+			field->fl_size = L;
+		(*str)++;
+	}
+}
+
+ssize_t	check_fields(const char **str, va_list ap, t_conv *field)
+{
+	init_struct_conv(field);
+	check_flags(str, field);
+	check_width(str, field, ap);
+	if (!(check_precision(str, field, ap)))
+		return (0);
+	check_size(str, field);
+	if (!(check_type_one(str, field)) || !(check_type_two(str, field)))
+		return (0);
+	if ((field->fl_type != d && field->fl_type != D && field->fl_type != i
+		&& field->fl_type != f) || field->fl_plus == 1)
+		field->fl_space = 0;
+	if (field->fl_type < s && field->fl_prec != -1)
+		field->fl_zero = 0;
+	else if (field->fl_type < s && field->fl_prec == -1)
+		field->fl_prec = 1;
+	if (field->fl_type == C && field->fl_size == h)
+		field->fl_type = c;
+	if (field->fl_type == c && field->fl_size == l)
+		field->fl_type = C;
+	if (field->fl_type == S && field->fl_size == h)
+		field->fl_type = s;
+	if (field->fl_type == s && field->fl_size == l)
+		field->fl_type = S;
+	return (1);
+}

libft/srcs/ft_printf_check_type.c

@@ -0,0 +1,69 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   check_type.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: klebon <klebon@student.42.fr>              +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/05/02 21:09:18 by klebon            #+#    #+#             */
+/*   Updated: 2019/03/07 22:18:05 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+ssize_t		check_type_one(const char **str, t_conv *field)
+{
+	if (**str == 'd' || **str == 'D' || **str == 'i' || **str == 'o'
+		|| **str == 'u' || **str == 'x' || **str == 'X' || **str == 's'
+		|| **str == 'S' || **str == 'c' || **str == 'C' || **str == 'U'
+		|| **str == 'p' || **str == '%' || **str == 'O' || **str == 'f')
+	{
+		if (**str == 'd')
+			field->fl_type = d;
+		else if (**str == 'D')
+			field->fl_type = D;
+		else if (**str == 'i')
+			field->fl_type = i;
+		else if (**str == 'o')
+			field->fl_type = o;
+		else if (**str == 'u')
+			field->fl_type = u;
+		else if (**str == 'U')
+			field->fl_type = U;
+		else if (**str == 'x')
+			field->fl_type = x;
+		else if (**str == 'X')
+			field->fl_type = X;
+		return (1);
+	}
+	return (0);
+}
+
+ssize_t		check_type_two(const char **str, t_conv *field)
+{
+	if (**str == 'd' || **str == 'D' || **str == 'i' || **str == 'o'
+		|| **str == 'u' || **str == 'x' || **str == 'X' || **str == 's'
+		|| **str == 'S' || **str == 'c' || **str == 'C' || **str == 'U'
+		|| **str == 'p' || **str == '%' || **str == 'O' || **str == 'f')
+	{
+		if (**str == 's')
+			field->fl_type = s;
+		else if (**str == 'S')
+			field->fl_type = S;
+		else if (**str == 'c')
+			field->fl_type = c;
+		else if (**str == 'C')
+			field->fl_type = C;
+		else if (**str == 'p')
+			field->fl_type = p;
+		else if (**str == '%')
+			field->fl_type = percent;
+		else if (**str == 'O')
+			field->fl_type = O;
+		else if (**str == 'f')
+			field->fl_type = f;
+		return (1);
+	}
+	return (0);
+}

libft/srcs/ft_printf_tools.c

@@ -0,0 +1,49 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   tools.c                                            :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: klebon <klebon@student.42.fr>              +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/05/02 21:49:45 by klebon            #+#    #+#             */
+/*   Updated: 2019/03/07 22:18:16 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void		init_struct_conv(t_conv *field)
+{
+	field->fl_minus = 0;
+	field->fl_plus = 0;
+	field->fl_zero = 0;
+	field->fl_hashtag = 0;
+	field->fl_space = 0;
+	field->fl_witdth = 0;
+	field->fl_prec = -1;
+	field->fl_size = -1;
+	field->fl_type = -1;
+	field->str = NULL;
+	field->str_size = 0;
+}
+
+char		*ft_strnewb(size_t size)
+{
+	size_t	i;
+	char	*str;
+
+	i = -1;
+	if (!(str = (char *)malloc(sizeof(char) * (size + 1))))
+		return (NULL);
+	while (++i < (size + 1))
+		str[i] = '\0';
+	return (str);
+}
+
+uint64_t	dmod(long double nb, long double mod)
+{
+	uint64_t	res;
+
+	res = (uint64_t)(nb - mod * (uint64_t)(nb / mod));
+	return (res);
+}

libft/srcs/ft_printf_tools_char.c

@@ -0,0 +1,30 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   tools_char.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: klebon <klebon@student.42.fr>              +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/05/19 08:51:48 by klebon            #+#    #+#             */
+/*   Updated: 2019/03/07 22:22:07 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+char	*handle_output_char(t_conv *field, va_list ap)
+{
+	char			*output;
+	unsigned char	c;
+
+	if (field->fl_type == percent)
+		c = '%';
+	else
+		c = (unsigned char)va_arg(ap, int);
+	field->str_size = (field->fl_witdth > 1) ? field->fl_witdth : 1;
+	if (!(output = ft_strnew(field->str_size)))
+		return (NULL);
+	output[0] = c;
+	ft_align_wchar(output, field);
+	return (output);
+}

libft/srcs/ft_printf_tools_float.c

@@ -0,0 +1,122 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_printf_tools_float.c                            :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/02/13 12:52:34 by tmaze             #+#    #+#             */
+/*   Updated: 2019/03/07 22:23:31 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void		roundup(char *str, long double n, int i, int prec)
+{
+	int	ret;
+	int	len;
+
+	ret = 1;
+	len = ft_strlen(str);
+	if ((int)n >= 5 && (n - (int)n) > 0.0)
+	{
+		while (i-- != 0 && ret == 1)
+		{
+			if (str[i] != '.' && str[i] + 1 > '9' && (ret = 1))
+				str[i] = '0';
+			else if (str[i] != '.' && !(ret = 0))
+				str[i]++;
+		}
+		if (ret == 1 && (i = ft_strlen(str)) < 4980)
+			while (--i > 0)
+				str[i + 1] = str[i];
+		str[0] = (ret == 1 && i < 4980) ? '1' : str[0];
+	}
+	i = 0;
+	while (str[i] && str[i] != '.')
+		i++;
+	i += prec + 1;
+	while (i < len)
+		str[i++] = '\0';
+}
+
+void		getint(char *str, long double n, int *i)
+{
+	uint64_t	nb;
+	long double	div;
+
+	nb = n;
+	div = 1;
+	while ((nb / div) >= 10)
+		div *= 10;
+	nb /= div;
+	while (*i < 4935 && div != 0)
+	{
+		str[*i] = (int)nb + '0';
+		div = (div == 1) ? 0 : (div / 10);
+		nb = dmod((n / div), 10);
+		(*i)++;
+	}
+}
+
+char		*getnbrstr(long double nb, t_conv *field)
+{
+	char		str[4980];
+	int			i;
+	int			j;
+
+	ft_bzero(str, 4980);
+	nb = nb * ((nb < 0.0) ? -1 : 1);
+	i = 0;
+	getint(str, nb, &i);
+	j = 0;
+	if (field->fl_prec > 0 || field->fl_hashtag)
+		str[i++] = '.';
+	nb = (nb - (uint64_t)nb) * ((nb < 0.0) ? -1 : 1) * 10;
+	while (j < field->fl_prec && i + j < 4980)
+	{
+		str[i + j] = (uint64_t)nb + '0';
+		nb = (nb - (uint64_t)nb) * 10;
+		j++;
+	}
+	i += j;
+	roundup(str, nb, i, field->fl_prec);
+	return (ft_strdup(str));
+}
+
+void		set_strf(t_conv *f, char *nbrstr, long double nb, int pad)
+{
+	if (!f->fl_minus && !f->fl_zero)
+		ft_memset(f->str, ' ', (pad > 0) ? pad : 0);
+	if (nb < 0.0)
+		f->str[ft_strlen(f->str)] = '-';
+	else if (f->fl_plus || f->fl_space)
+		f->str[ft_strlen(f->str)] = (f->fl_plus) ? '+' : ' ';
+	if (!f->fl_minus && f->fl_zero)
+		ft_memset(&f->str[ft_strlen(f->str)], '0', (pad > 0) ? pad : 0);
+	ft_strcat(f->str, nbrstr);
+	if (f->fl_minus)
+		ft_memset(&f->str[ft_strlen(f->str)], ' ', (pad > 0) ? pad : 0);
+}
+
+char		*handle_output_float(t_conv *field, va_list ap)
+{
+	long double	nb;
+	int			pad;
+	int			size;
+	char		*nbrstr;
+
+	if (field->fl_size == L)
+		nb = (long double)va_arg(ap, long double);
+	else
+		nb = (long double)va_arg(ap, double);
+	field->fl_prec = (field->fl_prec == -1) ? 6 : field->fl_prec;
+	nbrstr = getnbrstr(nb, field);
+	size = set_malloc_sizef(nb, nbrstr, field);
+	pad = field->str_size - size;
+	if ((field->str = ft_strnew(field->str_size)) != NULL)
+		set_strf(field, nbrstr, nb, pad);
+	ft_strdel(&nbrstr);
+	return (field->str);
+}

libft/srcs/ft_printf_tools_hexa.c

@@ -0,0 +1,120 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   tools_hexa.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: klebon <klebon@student.42.fr>              +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/05/13 19:58:30 by klebon            #+#    #+#             */
+/*   Updated: 2019/03/07 22:23:44 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+char	*handler_hexa(uintmax_t nb, t_conv *field)
+{
+	int			size;
+	uintmax_t	n;
+	char		*str;
+
+	size = set_precision_sizex(nb, field);
+	set_malloc_sizeh(nb, field);
+	if (!(str = ft_strnew(field->str_size)))
+		return (NULL);
+	n = nb;
+	while (n)
+	{
+		str[--size] = (field->fl_type == X) ? "0123456789ABCDEF"[n % 16]
+											: "0123456789abcdef"[n % 16];
+		n /= 16;
+	}
+	while (--size >= 0 && field->fl_prec)
+		str[size] = '0';
+	if (field->fl_hashtag)
+		str[1] = (field->fl_type == X) ? 'X' : 'x';
+	if (field->fl_hashtag)
+		str[0] = '0';
+	ft_align_hex(str, field);
+	return (str);
+}
+
+void	ft_align_hex_zero(char *str, t_conv *field)
+{
+	int		i;
+	int		len;
+
+	i = 0;
+	len = (int)ft_strlen(str);
+	if (field->fl_hashtag == 0 || (field->fl_hashtag == 1
+			&& field->fl_zero == 0))
+	{
+		ft_memmove(str + (field->str_size - len), str, len);
+		while (i < field->str_size - len)
+			str[i++] = (field->fl_zero) ? '0' : ' ';
+	}
+	else
+	{
+		i = 1;
+		ft_memmove(str + (field->str_size - len + 2), str + 2, len - 2);
+		while (++i < field->str_size - len + 2)
+			str[i] = '0';
+	}
+}
+
+void	ft_align_hex(char *str, t_conv *field)
+{
+	int		i;
+
+	i = 0;
+	if ((int)(ft_strlen(str)) < field->str_size)
+	{
+		if (field->fl_minus == 1)
+		{
+			while (str[i])
+				i++;
+			while (i < field->str_size)
+				str[i++] = ' ';
+		}
+		else
+		{
+			ft_align_hex_zero(str, field);
+		}
+	}
+}
+
+char	*select_hexa_handler(t_conv *field, va_list ap)
+{
+	uintmax_t	tmp;
+
+	if (field->fl_size == h)
+		tmp = (uintmax_t)(short unsigned int)va_arg(ap, unsigned int);
+	else if (field->fl_size == hh)
+		tmp = (uintmax_t)(unsigned char)va_arg(ap, unsigned int);
+	else if (field->fl_size == l)
+		tmp = (uintmax_t)va_arg(ap, long unsigned int);
+	else if (field->fl_size == ll)
+		tmp = (uintmax_t)va_arg(ap, unsigned long long int);
+	else if (field->fl_size == j)
+		tmp = va_arg(ap, uintmax_t);
+	else if (field->fl_size == z)
+		tmp = (uintmax_t)va_arg(ap, size_t);
+	else
+		tmp = (uintmax_t)va_arg(ap, unsigned int);
+	if (tmp == 0 && field->fl_type != p)
+		field->fl_hashtag = 0;
+	return (handler_hexa(tmp, field));
+}
+
+char	*handle_output_hexa(t_conv *field, va_list ap)
+{
+	char	*output;
+
+	if (field->fl_type == p)
+	{
+		field->fl_hashtag = 1;
+		field->fl_size = j;
+	}
+	output = select_hexa_handler(field, ap);
+	return (output);
+}

libft/srcs/ft_printf_tools_int.c

@@ -0,0 +1,113 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   tools_int.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: klebon <klebon@student.42.fr>              +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/05/10 14:02:42 by klebon            #+#    #+#             */
+/*   Updated: 2019/03/07 22:23:55 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+char	*handler_int(uintmax_t nb, t_conv *field)
+{
+	int			size;
+	uintmax_t	n;
+	char		*str;
+
+	size = set_precision_sizes(nb, field);
+	set_malloc_sizes(nb, field);
+	if (!(str = ft_strnew(field->str_size)))
+		return (NULL);
+	n = ((intmax_t)nb >= 0) ? (uintmax_t)nb : -(uintmax_t)nb;
+	while (n)
+	{
+		str[--size] = n % 10 + '0';
+		n /= 10;
+	}
+	while (--size >= 0 && field->fl_prec)
+		str[size] = '0';
+	if ((intmax_t)nb < 0)
+		str[0] = '-';
+	else if (field->fl_plus || field->fl_space)
+		str[0] = (field->fl_plus) ? '+' : ' ';
+	ft_align_str(str, field);
+	return (str);
+}
+
+void	ft_align_str_zero(char *str, t_conv *field)
+{
+	int		i;
+	int		len;
+
+	i = 0;
+	len = (int)ft_strlen(str);
+	if (field->fl_zero == 0
+		|| (str[0] != '-' && str[0] != '+' && str[0] != ' '))
+	{
+		ft_memmove(str + (field->str_size - len), str, len);
+		while (i < field->str_size - len)
+			str[i++] = (field->fl_zero && field->fl_prec == 1) ? '0' : ' ';
+	}
+	else
+	{
+		ft_memmove(str + (field->str_size - len + 1), str + 1, len - 1);
+		while (++i < field->str_size - len + 1)
+			str[i] = '0';
+	}
+}
+
+void	ft_align_str(char *str, t_conv *field)
+{
+	int		i;
+
+	i = 0;
+	if ((int)(ft_strlen(str)) < field->str_size)
+	{
+		if (field->fl_minus == 1)
+		{
+			while (str[i])
+				i++;
+			while (i < field->str_size)
+				str[i++] = ' ';
+		}
+		else
+		{
+			ft_align_str_zero(str, field);
+		}
+	}
+}
+
+char	*select_int_handler(t_conv *field, va_list ap)
+{
+	uintmax_t	tmp;
+
+	if (field->fl_size == h)
+		tmp = (uintmax_t)(short int)va_arg(ap, int);
+	else if (field->fl_size == hh)
+		tmp = (uintmax_t)(char)va_arg(ap, int);
+	else if (field->fl_size == l)
+		tmp = (uintmax_t)va_arg(ap, long int);
+	else if (field->fl_size == ll)
+		tmp = (uintmax_t)va_arg(ap, long long int);
+	else if (field->fl_size == j)
+		tmp = (uintmax_t)va_arg(ap, intmax_t);
+	else if (field->fl_size == z)
+		tmp = (uintmax_t)va_arg(ap, ssize_t);
+	else
+		tmp = (uintmax_t)va_arg(ap, int);
+	return (handler_int(tmp, field));
+}
+
+char	*handle_output_i_d(t_conv *field, va_list ap)
+{
+	char	*output;
+
+	if (field->fl_type == D)
+		field->fl_size = l;
+	output = select_int_handler(field, ap);
+	return (output);
+}

libft/srcs/ft_printf_tools_lenght.c

@@ -0,0 +1,50 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   tools_lenght.c                                     :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: klebon <klebon@student.42.fr>              +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/10/01 15:40:34 by klebon            #+#    #+#             */
+/*   Updated: 2019/03/07 22:19:06 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+unsigned int	ft_bin_size(unsigned int nb)
+{
+	unsigned int	n;
+	unsigned int	size;
+
+	n = nb;
+	size = 1;
+	while (n /= 2)
+		size++;
+	return (size);
+}
+
+int				ft_wstrlen(const wint_t *str)
+{
+	int				i;
+	int				len;
+
+	i = 0;
+	len = 0;
+	while (str[i])
+	{
+		if (str[i] < 0 || (MB_CUR_MAX == 1 && str[i] > 0xFF)
+				|| (str[i] >= 0xD800 && str[i] <= 0xDFFF) || str[i] > 0x10FFFF)
+			return (-1);
+		else if (str[i] <= 0x7F || (MB_CUR_MAX == 1 && str[i] <= 0xFF))
+			len += 1;
+		else if (str[i] <= 0x7FF)
+			len += 2;
+		else if (str[i] <= 0xFFFF)
+			len += 3;
+		else if (str[i] <= 0x10FFFF)
+			len += 4;
+		++i;
+	}
+	return (len);
+}

libft/srcs/ft_printf_tools_malloc_size.c

@@ -0,0 +1,79 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   tools_malloc_size.c                                :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: klebon <klebon@student.42.fr>              +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/10/01 13:43:37 by klebon            #+#    #+#             */
+/*   Updated: 2019/03/07 22:20:26 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	set_malloc_sizes(uintmax_t nb, t_conv *field)
+{
+	uintmax_t	tmp;
+
+	if (nb == 0 && field->fl_prec == 0)
+		field->str_size = 0;
+	else
+		field->str_size = 1;
+	tmp = ((intmax_t)nb >= 0) ? (uintmax_t)nb : -(uintmax_t)nb;
+	while (tmp /= 10)
+		++field->str_size;
+	field->str_size = (field->str_size < field->fl_prec)
+					? field->fl_prec : field->str_size;
+	field->str_size += ((intmax_t)nb < 0 || field->fl_plus
+					|| field->fl_space) ? 1 : 0;
+	field->str_size = (field->str_size < field->fl_witdth)
+					? field->fl_witdth : field->str_size;
+}
+
+void	set_malloc_sizeh(uintmax_t nb, t_conv *field)
+{
+	uintmax_t	tmp;
+
+	if (nb == 0 && field->fl_prec == 0)
+		field->str_size = 0;
+	else
+		field->str_size = 1;
+	tmp = nb;
+	while (tmp /= 16)
+		field->str_size++;
+	field->str_size = (field->str_size < field->fl_prec)
+					? field->fl_prec : field->str_size;
+	field->str_size += (field->fl_hashtag) ? 2 : 0;
+	field->str_size = (field->str_size < field->fl_witdth)
+					? field->fl_witdth : field->str_size;
+}
+
+void	set_malloc_sizeo(uintmax_t nb, t_conv *field)
+{
+	uintmax_t	tmp;
+
+	if (nb == 0)
+		field->str_size = 0;
+	else
+		field->str_size = 1;
+	tmp = nb;
+	while (tmp /= 8)
+		++field->str_size;
+	field->str_size += (field->fl_hashtag) ? 1 : 0;
+	field->str_size = (field->str_size < field->fl_prec)
+					? field->fl_prec : field->str_size;
+	field->str_size = (field->str_size < field->fl_witdth)
+					? field->fl_witdth : field->str_size;
+}
+
+int		set_malloc_sizef(long double nb, char *nbrstr, t_conv *field)
+{
+	int	size;
+
+	size = ft_strlen(nbrstr);
+	if (nb < 0.0 || field->fl_plus || field->fl_space)
+		size++;
+	field->str_size = (field->fl_witdth > size) ? field->fl_witdth : size;
+	return (size);
+}

libft/srcs/ft_printf_tools_oct.c

@@ -0,0 +1,110 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   tools_oct.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: klebon <klebon@student.42.fr>              +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/05/13 20:13:28 by klebon            #+#    #+#             */
+/*   Updated: 2019/03/07 22:24:23 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+char	*handler_oct(uintmax_t nb, t_conv *field)
+{
+	int			size;
+	uintmax_t	n;
+	char		*str;
+
+	size = set_precision_sizeo(nb, field);
+	set_malloc_sizeo(nb, field);
+	if (!(str = ft_strnew(field->str_size)))
+		return (NULL);
+	n = nb;
+	while (n)
+	{
+		str[--size] = n % 8 + '0';
+		n /= 8;
+	}
+	while (--size >= 0 && field->fl_prec)
+		str[size] = '0';
+	if (field->fl_hashtag)
+		str[0] = '0';
+	ft_align_oct(str, field);
+	return (str);
+}
+
+void	ft_align_oct_zero(char *str, t_conv *field)
+{
+	int		i;
+	int		len;
+
+	i = 0;
+	len = (int)ft_strlen(str);
+	if (field->fl_zero == 0 || field->fl_hashtag == 0)
+	{
+		ft_memmove(str + (field->str_size - len), str, len);
+		while (i < field->str_size - len)
+			str[i++] = (field->fl_zero) ? '0' : ' ';
+	}
+	else
+	{
+		ft_memmove(str + (field->str_size - len + 1), str + 1, len - 1);
+		while (++i < field->str_size - len + 1)
+			str[i] = '0';
+	}
+}
+
+void	ft_align_oct(char *str, t_conv *field)
+{
+	int		i;
+
+	i = 0;
+	if ((int)(ft_strlen(str)) < field->str_size)
+	{
+		if (field->fl_minus == 1)
+		{
+			while (str[i])
+				i++;
+			while (i < field->str_size)
+				str[i++] = ' ';
+		}
+		else
+		{
+			ft_align_oct_zero(str, field);
+		}
+	}
+}
+
+char	*select_oct_handler(t_conv *field, va_list ap)
+{
+	uintmax_t	tmp;
+
+	if (field->fl_size == h)
+		tmp = (uintmax_t)(short unsigned int)va_arg(ap, unsigned int);
+	else if (field->fl_size == hh)
+		tmp = (uintmax_t)(unsigned char)va_arg(ap, unsigned int);
+	else if (field->fl_size == l)
+		tmp = (uintmax_t)va_arg(ap, long unsigned int);
+	else if (field->fl_size == ll)
+		tmp = (uintmax_t)va_arg(ap, unsigned long long int);
+	else if (field->fl_size == j)
+		tmp = va_arg(ap, uintmax_t);
+	else if (field->fl_size == z)
+		tmp = (uintmax_t)va_arg(ap, size_t);
+	else
+		tmp = (uintmax_t)va_arg(ap, unsigned int);
+	return (handler_oct(tmp, field));
+}
+
+char	*handle_output_oct(t_conv *field, va_list ap)
+{
+	char	*output;
+
+	if (field->fl_type == O)
+		field->fl_size = l;
+	output = select_oct_handler(field, ap);
+	return (output);
+}

libft/srcs/ft_printf_tools_prec_size.c

@@ -0,0 +1,97 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   tools_prec_size.c                                  :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: klebon <klebon@student.42.fr>              +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/10/01 15:36:42 by klebon            #+#    #+#             */
+/*   Updated: 2019/03/07 22:20:49 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int		set_precision_sizex(uintmax_t nb, t_conv *field)
+{
+	uintmax_t	tmp;
+	int			size;
+
+	if (nb == 0 && field->fl_prec == 0)
+		size = 0;
+	else
+		size = 1;
+	tmp = nb;
+	while (tmp /= 16)
+		++size;
+	size = (size < field->fl_prec) ? field->fl_prec : size;
+	size += (field->fl_hashtag) ? 2 : 0;
+	return (size);
+}
+
+int		set_precision_sizes(uintmax_t nb, t_conv *field)
+{
+	uintmax_t	tmp;
+	int			size;
+
+	if (nb == 0 && field->fl_prec == 0)
+		size = 0;
+	else
+		size = 1;
+	tmp = ((intmax_t)nb >= 0) ? (uintmax_t)nb : -(uintmax_t)nb;
+	while (tmp /= 10)
+		++size;
+	size = (size < field->fl_prec) ? field->fl_prec : size;
+	size += ((intmax_t)nb < 0 || field->fl_plus || field->fl_space) ? 1 : 0;
+	return (size);
+}
+
+int		set_precision_sizeo(uintmax_t nb, t_conv *field)
+{
+	uintmax_t	tmp;
+	int			size;
+
+	if (nb == 0 && field->fl_prec == 0)
+		size = 0;
+	else if (nb == 0)
+	{
+		size = 0;
+		field->fl_hashtag = 0;
+	}
+	else
+		size = 1;
+	tmp = nb;
+	while (tmp /= 8)
+		++size;
+	size += (field->fl_hashtag) ? 1 : 0;
+	size = (size < field->fl_prec) ? field->fl_prec : size;
+	return (size);
+}
+
+int		set_prec_size_wstr(const wint_t *str, t_conv *field)
+{
+	int				i;
+	int				tmp;
+
+	i = 0;
+	field->str_size = 0;
+	while (str[i] && (field->str_size < field->fl_prec))
+	{
+		tmp = field->str_size;
+		if (str[i] < 0 || (MB_CUR_MAX == 1 && str[i] > 0xFF)
+				|| (str[i] >= 0xD800 && str[i] <= 0xDFFF) || str[i] > 0x10FFFF)
+			return (0);
+		else if (str[i] <= 0x7F || (MB_CUR_MAX == 1 && str[i] <= 0xFF))
+			field->str_size += (field->str_size + 1 <= field->fl_prec) ? 1 : 0;
+		else if (str[i] <= 0x7FF)
+			field->str_size += (field->str_size + 2 <= field->fl_prec) ? 2 : 0;
+		else if (str[i] <= 0xFFFF)
+			field->str_size += (field->str_size + 3 <= field->fl_prec) ? 3 : 0;
+		else if (str[i] <= 0x10FFFF)
+			field->str_size += (field->str_size + 4 <= field->fl_prec) ? 4 : 0;
+		if (tmp == field->str_size)
+			return (1);
+		++i;
+	}
+	return (1);
+}

libft/srcs/ft_printf_tools_str.c

@@ -0,0 +1,64 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_printf_tools_str.c                              :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: klebon <klebon@student.42.fr>              +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/05/19 09:05:22 by klebon            #+#    #+#             */
+/*   Updated: 2019/03/07 22:27:38 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_align_wstr(char *str, t_conv *field)
+{
+	int		i;
+	int		len;
+
+	i = 0;
+	if (field->fl_witdth >= 1)
+	{
+		if (field->fl_minus)
+		{
+			while (str[i])
+				i++;
+			while (i < field->str_size)
+				str[i++] = ' ';
+		}
+		else
+		{
+			len = (int)ft_strlen(str);
+			ft_memmove(str + (field->str_size - len), str, len);
+			while (i < (field->str_size - len))
+			{
+				str[i] = ' ';
+				i++;
+			}
+		}
+	}
+}
+
+char	*handle_output_str(t_conv *field, va_list ap)
+{
+	char		*output;
+	int			len;
+	const char	*str;
+
+	str = va_arg(ap, const char *);
+	if (str == NULL)
+		str = "(null)";
+	len = (int)ft_strlen(str);
+	if (field->fl_prec != -1)
+		len = (len > field->fl_prec) ? field->fl_prec : len;
+	field->str_size = (field->fl_witdth > len) ? field->fl_witdth : len;
+	if (!(output = ft_strnew(field->str_size)))
+		return (NULL);
+	if (field->fl_prec == -1)
+		ft_strcpy(output, str);
+	else
+		ft_strncpy(output, str, len);
+	ft_align_wstr(output, field);
+	return (output);
+}

libft/srcs/ft_printf_tools_unsigned_int.c

@@ -0,0 +1,99 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   tools_unsigned_int.c                               :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: klebon <klebon@student.42.fr>              +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/05/13 19:43:31 by klebon            #+#    #+#             */
+/*   Updated: 2019/03/07 22:25:00 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	set_malloc_sizeu(uintmax_t nb, t_conv *field)
+{
+	uintmax_t	tmp;
+
+	if (nb == 0 && field->fl_prec == 0)
+		field->str_size = 0;
+	else
+		field->str_size = 1;
+	tmp = nb;
+	while (tmp /= 10)
+		++field->str_size;
+	field->str_size = (field->str_size < field->fl_prec)
+					? field->fl_prec : field->str_size;
+	field->str_size = (field->str_size < field->fl_witdth)
+					? field->fl_witdth : field->str_size;
+}
+
+int		set_precision_sizeu(uintmax_t nb, t_conv *field)
+{
+	uintmax_t	tmp;
+	int			size;
+
+	if (nb == 0 && field->fl_prec == 0)
+		size = 0;
+	else
+		size = 1;
+	tmp = nb;
+	while (tmp /= 10)
+		++size;
+	size = (size < field->fl_prec) ? field->fl_prec : size;
+	return (size);
+}
+
+char	*handler_uns(uintmax_t nb, t_conv *field)
+{
+	int			size;
+	uintmax_t	n;
+	char		*str;
+
+	size = set_precision_sizeu(nb, field);
+	set_malloc_sizeu(nb, field);
+	if (!(str = ft_strnew(field->str_size)))
+		return (NULL);
+	n = nb;
+	while (n)
+	{
+		str[--size] = n % 10 + '0';
+		n /= 10;
+	}
+	while (--size >= 0 && field->fl_prec)
+		str[size] = '0';
+	ft_align_str(str, field);
+	return (str);
+}
+
+char	*select_uns_int_handler(t_conv *field, va_list ap)
+{
+	uintmax_t	tmp;
+
+	if (field->fl_size == h)
+		tmp = (uintmax_t)(short unsigned int)va_arg(ap, unsigned int);
+	else if (field->fl_size == hh)
+		tmp = (uintmax_t)(unsigned char)va_arg(ap, unsigned int);
+	else if (field->fl_size == l)
+		tmp = (uintmax_t)va_arg(ap, long unsigned int);
+	else if (field->fl_size == ll)
+		tmp = (uintmax_t)va_arg(ap, unsigned long long int);
+	else if (field->fl_size == j)
+		tmp = va_arg(ap, uintmax_t);
+	else if (field->fl_size == z)
+		tmp = (uintmax_t)va_arg(ap, size_t);
+	else
+		tmp = (uintmax_t)va_arg(ap, unsigned int);
+	return (handler_uns(tmp, field));
+}
+
+char	*handle_output_u(t_conv *field, va_list ap)
+{
+	char	*output;
+
+	if (field->fl_type == U)
+		field->fl_size = l;
+	output = select_uns_int_handler(field, ap);
+	return (output);
+}

libft/srcs/ft_printf_tools_wchar_t.c

@@ -0,0 +1,109 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   tools_wchar_t.c                                    :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: klebon <klebon@student.42.fr>              +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/05/18 18:10:11 by klebon            #+#    #+#             */
+/*   Updated: 2019/03/16 15:53:50 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void			ft_align_wchar(char *str, t_conv *field)
+{
+	int		i;
+	int		len;
+
+	len = (int)ft_strlen(str);
+	len = (len) ? len : 1;
+	if (len < field->str_size)
+	{
+		if (field->fl_minus == 1)
+		{
+			i = 1;
+			while (str[i])
+				++i;
+			while (i < field->str_size)
+				str[i++] = ' ';
+		}
+		else
+		{
+			i = 0;
+			ft_memmove(str + (field->str_size - len), str, len);
+			while (i < field->str_size - len)
+				str[i++] = (field->fl_zero) ? '0' : ' ';
+		}
+	}
+}
+
+char			*handler_2oct_char(wint_t c, t_conv *field)
+{
+	char	*output;
+
+	field->str_size = (field->fl_witdth > 2) ? field->fl_witdth : 2;
+	if (!(output = ft_strnew(field->str_size)))
+		return (NULL);
+	output[0] = (c >> 6) + 0xC0;
+	output[1] = (c & 0x3F) + 0x80;
+	ft_align_wchar(output, field);
+	return (output);
+}
+
+char			*handler_3oct_char(wint_t c, t_conv *field)
+{
+	char	*output;
+
+	field->str_size = (field->fl_witdth > 3) ? field->fl_witdth : 3;
+	if (!(output = ft_strnew(field->str_size)))
+		return (NULL);
+	output[0] = (c >> 12) + 0xE0;
+	output[1] = ((c >> 6) & 0x3F) + 0x80;
+	output[2] = (c & 0x3F) + 0x80;
+	ft_align_wchar(output, field);
+	return (output);
+}
+
+char			*handler_4oct_char(wint_t c, t_conv *field)
+{
+	char			*output;
+
+	field->str_size = (field->fl_witdth > 4) ? field->fl_witdth : 4;
+	if (!(output = ft_strnew(field->str_size)))
+		return (NULL);
+	output[0] = (c >> 18) + 0xF0;
+	output[1] = ((c >> 12) & 0x3F) + 0x80;
+	output[2] = ((c >> 6) & 0x3F) + 0x80;
+	output[3] = (c & 0x3F) + 0x80;
+	ft_align_wchar(output, field);
+	return (output);
+}
+
+char			*handle_output_wchar(t_conv *field, va_list ap)
+{
+	char	*output;
+	wint_t	c;
+
+	c = (wint_t)va_arg(ap, wint_t);
+	if (c < 0 || (MB_CUR_MAX == 1 && c > 0xFF) || (c >= 0xD800 && c <= 0xDFFF))
+		return (NULL);
+	else if (c <= 0x7F || (MB_CUR_MAX == 1 && c <= 0xFF))
+	{
+		field->str_size = (field->fl_witdth > 1) ? field->fl_witdth : 1;
+		if (!(output = ft_strnew(field->str_size)))
+			return (NULL);
+		output[0] = (char)c;
+		ft_align_wchar(output, field);
+	}
+	else if (c <= 0x7FF)
+		output = handler_2oct_char(c, field);
+	else if (c <= 0xFFFF)
+		output = handler_3oct_char(c, field);
+	else if (c <= 0x10FFFF)
+		output = handler_4oct_char(c, field);
+	else
+		return (NULL);
+	return (output);
+}

libft/srcs/ft_printf_tools_wstr.c

@@ -0,0 +1,89 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   tools_wstr.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: klebon <klebon@student.42.fr>              +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/05/23 19:48:06 by klebon            #+#    #+#             */
+/*   Updated: 2019/03/07 22:25:19 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void		handler_2oct_wstr(wint_t c, char *output, int *i)
+{
+	output[(*i)++] = (c >> 6) + 0xC0;
+	output[(*i)++] = (c & 0x3F) + 0x80;
+}
+
+void		handler_3oct_wstr(wint_t c, char *output, int *i)
+{
+	output[(*i)++] = (c >> 12) + 0xE0;
+	output[(*i)++] = ((c >> 6) & 0x3F) + 0x80;
+	output[(*i)++] = (c & 0x3F) + 0x80;
+}
+
+void		handler_4oct_wstr(wint_t c, char *output, int *i)
+{
+	output[(*i)++] = (c >> 18) + 0xF0;
+	output[(*i)++] = ((c >> 12) & 0x3F) + 0x80;
+	output[(*i)++] = ((c >> 6) & 0x3F) + 0x80;
+	output[(*i)++] = (c & 0x3F) + 0x80;
+}
+
+void		convert_wstr_to_str(const wint_t *str, char *output, t_conv *field)
+{
+	int				i;
+	int				j;
+	int				tmp;
+
+	i = 0;
+	j = 0;
+	while (str[i] && j <= field->fl_prec)
+	{
+		tmp = j;
+		if (j + 1 <= field->fl_prec
+				&& (str[i] <= 0x7F || (MB_CUR_MAX == 1 && str[i] <= 0xFF)))
+			output[j++] = (char)str[i];
+		else if (j + 2 <= field->fl_prec && str[i] <= 0x7FF)
+			handler_2oct_wstr(str[i], output, &j);
+		else if (j + 3 <= field->fl_prec && str[i] <= 0xFFFF)
+			handler_3oct_wstr(str[i], output, &j);
+		else if (j + 4 <= field->fl_prec)
+			handler_4oct_wstr(str[i], output, &j);
+		++i;
+		if (tmp == j)
+			break ;
+	}
+}
+
+char		*handle_output_wstr(t_conv *field, va_list ap)
+{
+	char			*output;
+	const wint_t	*str;
+
+	str = (wint_t *)va_arg(ap, const wint_t *);
+	if (str == NULL)
+		str = L"(null)";
+	if (field->fl_prec != -1)
+	{
+		if (set_prec_size_wstr(str, field) == 0)
+			return (NULL);
+	}
+	else
+	{
+		if ((field->str_size = ft_wstrlen(str)) == -1)
+			return (NULL);
+	}
+	if (field->fl_prec == -1)
+		field->fl_prec = field->str_size;
+	if (field->fl_witdth > field->str_size)
+		field->str_size += (field->fl_witdth - field->str_size);
+	if (!(output = ft_strnew(field->str_size)))
+		return (NULL);
+	convert_wstr_to_str(str, output, field);
+	ft_align_wstr(output, field);
+	return (output);
+}

libft/srcs/ft_putchar.c

@@ -0,0 +1,18 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_putchar.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/07 19:03:57 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/07 23:02:29 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_putchar(char c)
+{
+	write(1, &c, 1);
+}

libft/srcs/ft_putchar_fd.c

@@ -0,0 +1,18 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_putchar_fd.c                                    :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/07 22:43:23 by tmaze             #+#    #+#             */
+/*   Updated: 2018/05/01 13:37:42 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_putchar_fd(char c, int fd)
+{
+	write(fd, &c, 1);
+}

libft/srcs/ft_putendl.c

@@ -0,0 +1,20 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_putendl.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/07 22:37:44 by tmaze             #+#    #+#             */
+/*   Updated: 2019/03/19 14:50:20 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_putendl(char const *s)
+{
+	if (s != NULL)
+		ft_putstr(s);
+	ft_putchar('\n');
+}

libft/srcs/ft_putendl2.c

@@ -0,0 +1,28 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_putendl2.c                                      :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/03/19 15:14:49 by tmaze             #+#    #+#             */
+/*   Updated: 2019/03/20 17:00:52 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int	ft_putendl2(char const *s)
+{
+	char	*str;
+
+	if (s != NULL && (str = ft_strnew(ft_strlen(s) + 1)) != NULL)
+	{
+		ft_strcpy(str, s);
+		ft_strcat(str, "\n");
+		ft_putstr(str);
+		ft_strdel(&str);
+		return (0);
+	}
+	return (1);
+}

libft/srcs/ft_putendl_fd.c

@@ -0,0 +1,22 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_putendl_fd.c                                    :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/08 13:02:13 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/10 14:27:49 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_putendl_fd(char const *s, int fd)
+{
+	if (s != NULL && fd >= 0)
+	{
+		ft_putstr_fd(s, fd);
+		ft_putchar_fd('\n', fd);
+	}
+}

libft/srcs/ft_putendl_fd2.c

@@ -0,0 +1,28 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_putendl_fd2.c                                   :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/03/20 16:44:51 by tmaze             #+#    #+#             */
+/*   Updated: 2019/03/20 17:00:16 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int	ft_putendl_fd2(char const *s, int fd)
+{
+	char	*str;
+
+	if (s != NULL && (str = ft_strnew(ft_strlen(s) + 1)) != NULL)
+	{
+		ft_strcpy(str, s);
+		ft_strcat(str, "\n");
+		ft_putstr_fd(str, fd);
+		ft_strdel(&str);
+		return (0);
+	}
+	return (1);
+}

libft/srcs/ft_putnbr.c

@@ -0,0 +1,18 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_putnbr.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/08 12:52:53 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/08 15:33:50 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_putnbr(int n)
+{
+	ft_putnbr_fd(n, 1);
+}

libft/srcs/ft_putnbr_fd.c

@@ -0,0 +1,33 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_putnbr_fd.c                                     :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/08 13:05:24 by tmaze             #+#    #+#             */
+/*   Updated: 2018/05/05 16:50:14 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void					ft_putnbr_fd(int n, int fd)
+{
+	unsigned long	mult;
+	int				nb_nbr;
+	unsigned long	nbr;
+
+	mult = 10;
+	nbr = ft_abs(n);
+	while (mult <= nbr)
+		mult *= 10;
+	if (n < 0)
+		write(fd, "-", 1);
+	while (mult > 1)
+	{
+		nb_nbr = '0' + ((nbr % mult) / (mult / 10));
+		write(fd, &nb_nbr, 1);
+		mult /= 10;
+	}
+}

libft/srcs/ft_putnbrpad.c

@@ -0,0 +1,24 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_putnbrpad.c                                     :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/07/31 13:51:17 by tmaze             #+#    #+#             */
+/*   Updated: 2018/07/31 14:04:43 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_putnbrpad(int nbr, size_t size, char pad, char align)
+{
+	if (align == 'd')
+		while (size-- != 0)
+			ft_putchar(pad);
+	ft_putnbr(nbr);
+	if (align == 'g')
+		while (size-- != 0)
+			ft_putchar(pad);
+}

libft/srcs/ft_putstr.c

@@ -0,0 +1,19 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_putstr.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/07 19:13:17 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/12 11:23:29 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_putstr(char const *s)
+{
+	if (s != NULL)
+		write(1, s, ft_strlen(s));
+}

libft/srcs/ft_putstr_fd.c

@@ -0,0 +1,19 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_putstr_fd.c                                     :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/07 23:06:30 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/10 14:26:43 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_putstr_fd(char const *s, int fd)
+{
+	if (s != NULL && fd >= 0)
+		write(fd, s, ft_strlen(s));
+}

libft/srcs/ft_putstrn.c

@@ -0,0 +1,24 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_putstrn.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/07/25 16:20:52 by tmaze             #+#    #+#             */
+/*   Updated: 2018/07/25 16:24:41 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_putstrn(char	const *s, size_t nb)
+{
+	size_t	strlen;
+
+	if (s != NULL)
+	{
+		strlen = ft_strlen(s);
+		write(1, s, (nb < strlen) ? nb : strlen);
+	}
+}

libft/srcs/ft_putstrpad.c

@@ -0,0 +1,24 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_putstrpad.c                                     :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/07/31 13:36:56 by tmaze             #+#    #+#             */
+/*   Updated: 2018/07/31 14:05:41 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_putstrpad(char *str, size_t size, char pad, char align)
+{
+	if (align == 'd')
+		while (size-- != 0)
+			ft_putchar(pad);
+	ft_putstr(str);
+	if (align == 'g')
+		while (size-- != 0)
+			ft_putchar(pad);
+}

libft/srcs/ft_realpath.c

@@ -0,0 +1,77 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_realpath.c                                      :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2019/01/27 14:42:35 by tmaze             #+#    #+#             */
+/*   Updated: 2019/01/29 18:16:22 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+char	*ft_tabtopath(char **tab_path)
+{
+	size_t	total_size;
+	size_t	i;
+	char	*ret;
+
+	i = 0;
+	total_size = 0;
+	while (tab_path[i])
+		total_size += ft_strlen(tab_path[i++]);
+	total_size = (total_size == 0) ? 1 : total_size;
+	if ((ret = ft_strnew(total_size + i)) == NULL)
+		return (NULL);
+	i = 0;
+	ft_strcat(ret, "/");
+	while (tab_path[i])
+	{
+		if (i > 0)
+			ft_strcat(ret, "/");
+		ft_strcat(ret, tab_path[i++]);
+	}
+	return (ret);
+}
+
+void	ft_reducepath(char ***tab)
+{
+	size_t	i;
+	size_t	j;
+	int		strcmp;
+
+	i = 0;
+	while ((*tab)[i])
+	{
+		if ((strcmp = ft_strcmp((*tab)[i], "..")) == 0
+			|| ft_strcmp((*tab)[i], ".") == 0)
+		{
+			ft_strdel(&((*tab)[i]));
+			if ((j = i) == i && strcmp == 0 && i != 0)
+				ft_strdel(&((*tab)[i - 1]));
+			while ((*tab)[++j])
+				(*tab)[j - ((strcmp == 0 && i != 0) ? 2 : 1)] = (*tab)[j];
+			if (strcmp == 0 && i != 0)
+				(*tab)[j - 2] = NULL;
+			(*tab)[j - 1] = NULL;
+			if (strcmp == 0 && i != 0)
+				i--;
+		}
+		else
+			i++;
+	}
+}
+
+char	*ft_realpath(char *r_path, char **a_path)
+{
+	char	**tab_path;
+
+	if ((tab_path = ft_strsplit(r_path, '/')) == NULL)
+		return (NULL);
+	ft_reducepath(&tab_path);
+	*a_path = ft_tabtopath(tab_path);
+	ft_del_words_tables(&tab_path);
+	return (*a_path);
+}

libft/srcs/ft_round.c

@@ -0,0 +1,20 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_round.c                                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/10/24 13:37:41 by tmaze             #+#    #+#             */
+/*   Updated: 2018/10/24 13:37:52 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int	ft_round(float x, float ind)
+{
+	if ((x - (int)x) > ind)
+		return ((int)x + 1);
+	return ((int)x);
+}

libft/srcs/ft_sort_params.c

@@ -0,0 +1,32 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_sort_params.c                                   :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/09 18:28:43 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/09 19:04:57 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_sort_params(int ac, char **av)
+{
+	int		i;
+	int		j;
+	char	*tmp;
+
+	i = 1;
+	while (++i < ac && (j = i))
+	{
+		tmp = av[i];
+		while (j > 1 && ft_strcmp(av[j - 1], tmp) > 0)
+		{
+			av[j] = av[j - 1];
+			j--;
+		}
+		av[j] = tmp;
+	}
+}

libft/srcs/ft_str_is_alpha.c

@@ -0,0 +1,24 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_str_is_alpha.c                                  :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/09 10:29:18 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/09 10:33:32 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int	ft_str_is_alpha(char *str)
+{
+	int	i;
+
+	i = 0;
+	while (str[i])
+		if (!ft_isalpha(str[i++]))
+			return (0);
+	return (1);
+}

libft/srcs/ft_str_is_lowercase.c

@@ -0,0 +1,24 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_str_is_lowercase.c                              :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/09 10:29:18 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/09 10:47:19 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int	ft_str_is_lowercase(char *str)
+{
+	int	i;
+
+	i = 0;
+	while (str[i])
+		if (!ft_islower(str[i++]))
+			return (0);
+	return (1);
+}

libft/srcs/ft_str_is_numeric.c

@@ -0,0 +1,24 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_str_is_numeric.c                                :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/09 10:29:18 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/09 10:59:32 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int	ft_str_is_numeric(char *str)
+{
+	int	i;
+
+	i = 0;
+	while (str[i])
+		if (!ft_isdigit(str[i++]))
+			return (0);
+	return (1);
+}

libft/srcs/ft_str_is_printable.c

@@ -0,0 +1,24 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_str_is_printable.c                              :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/09 10:29:18 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/09 11:11:56 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int	ft_str_is_printable(char *str)
+{
+	int	i;
+
+	i = 0;
+	while (str[i])
+		if (!ft_isprint(str[i++]))
+			return (0);
+	return (1);
+}

libft/srcs/ft_str_is_uppercase.c

@@ -0,0 +1,24 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_str_is_uppercase.c                              :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/09 10:29:18 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/09 11:01:45 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int	ft_str_is_uppercase(char *str)
+{
+	int	i;
+
+	i = 0;
+	while (str[i])
+		if (!ft_isupper(str[i++]))
+			return (0);
+	return (1);
+}

libft/srcs/ft_strcapitalize.c

@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_strcapitalize.c                                 :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/09 11:16:16 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/09 11:31:18 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+char	*ft_strcapitalize(char *str)
+{
+	unsigned int	i;
+
+	i = 0;
+	while (str[i])
+	{
+		if (i == 0 || !ft_isalnum(str[i - 1]))
+			str[i] = ft_toupper(str[i]);
+		else if (ft_isalnum(str[i - 1]))
+			str[i] = ft_tolower(str[i]);
+		i++;
+	}
+	return (str);
+}

libft/srcs/ft_strcat.c

@@ -0,0 +1,22 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_strcat.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/04 17:56:56 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/04 18:21:46 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+char	*ft_strcat(char *dest, const char *src)
+{
+	int dest_len;
+
+	dest_len = ft_strlen(dest);
+	ft_strcpy(&dest[dest_len], src);
+	return (dest);
+}

libft/srcs/ft_strchr.c

@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_strchr.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/04 18:54:17 by tmaze             #+#    #+#             */
+/*   Updated: 2018/05/16 15:09:08 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+char	*ft_strchr(const char *s, int c)
+{
+	int		i;
+	char	*tmp;
+
+	if (s != NULL)
+	{
+		i = -1;
+		tmp = (char*)s;
+		while (++i == 0 || tmp[i - 1])
+			if (tmp[i] == c)
+				return (&tmp[i]);
+	}
+	return (NULL);
+}

libft/srcs/ft_strclr.c

@@ -0,0 +1,23 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_strclr.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/06 23:27:33 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/10 14:04:24 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_strclr(char *s)
+{
+	int	i;
+
+	i = 0;
+	if (s != NULL)
+		while (s[i])
+			s[i++] = '\0';
+}

libft/srcs/ft_strcmp.c

@@ -0,0 +1,24 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_strcmp.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: mndhlovu <marvin@42.fr>                    +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/11/07 17:33:42 by mndhlovu          #+#    #+#             */
+/*   Updated: 2018/11/09 17:56:30 by mndhlovu         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+#include <string.h>
+
+int		ft_strcmp(const char *s1, const char *s2)
+{
+	size_t		len;
+
+	len = 0;
+	while (s1[len] && s2[len] && s1[len] == s2[len])
+		len++;
+	return ((unsigned char)s1[len] - (unsigned char)s2[len]);
+}

libft/srcs/ft_strcpy.c

@@ -0,0 +1,23 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_strcpy.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/04 16:15:42 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/04 19:19:41 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+char	*ft_strcpy(char *dest, const char *src)
+{
+	int i;
+
+	i = -1;
+	while (++i == 0 || src[i - 1])
+		dest[i] = src[i];
+	return (dest);
+}

libft/srcs/ft_strdel.c

@@ -0,0 +1,18 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_strdel.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/06 18:59:40 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/06 19:14:01 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_strdel(char **as)
+{
+	ft_memdel((void**)as);
+}

libft/srcs/ft_strdup.c

@@ -0,0 +1,22 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_strdup.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/03 16:33:35 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/09 09:52:08 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+char	*ft_strdup(const char *s1)
+{
+	char *ret;
+
+	if ((ret = ft_strnew(ft_strlen(s1))) != NULL)
+		ft_strcpy(ret, s1);
+	return (ret);
+}

libft/srcs/ft_strequ.c

@@ -0,0 +1,18 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_strequ.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/07 15:10:56 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/10 14:09:20 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+int	ft_strequ(char const *s1, char const *s2)
+{
+	return ((s1 != NULL && s2 != NULL) ? ft_strcmp(s1, s2) == 0 : 0);
+}

libft/srcs/ft_striter.c

@@ -0,0 +1,23 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_striter.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/07 11:17:26 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/10 14:05:25 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_striter(char *s, void (*f)(char*))
+{
+	unsigned int	i;
+
+	i = 0;
+	if (s != NULL && f != NULL)
+		while (s[i])
+			(*f)(&s[i++]);
+}

libft/srcs/ft_striteri.c

@@ -0,0 +1,23 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_striteri.c                                      :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <marvin@42.fr>                       +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/07 11:36:12 by tmaze             #+#    #+#             */
+/*   Updated: 2018/04/10 14:06:17 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+void	ft_striteri(char *s, void (*f)(unsigned int, char*))
+{
+	unsigned int	i;
+
+	i = -1;
+	if (s != NULL && f != NULL)
+		while (s[++i])
+			(*f)(i, &s[i]);
+}

libft/srcs/ft_strjoin.c

@@ -0,0 +1,27 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_strjoin.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/07 16:30:47 by tmaze             #+#    #+#             */
+/*   Updated: 2019/03/16 15:39:59 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+char	*ft_strjoin(char const *s1, char const *s2)
+{
+	char	*ret;
+
+	ret = NULL;
+	if (s1 != NULL && s2 != NULL
+		&& (ret = ft_strnew(ft_strlen(s1) + ft_strlen(s2))) != NULL)
+	{
+		ft_strcpy(ret, s1);
+		ft_strcat(ret, s2);
+	}
+	return (ret);
+}

libft/srcs/ft_strlcat.c

@@ -0,0 +1,27 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_strlcat.c                                       :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: tmaze <tmaze@student.42.fr>                +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2018/04/08 14:32:30 by tmaze             #+#    #+#             */
+/*   Updated: 2019/03/16 15:45:42 by tmaze            ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "libft.h"
+
+size_t	ft_strlcat(char *dest, const char *src, size_t size)
+{
+	int		dest_len;
+
+	dest_len = ft_strlen(dest);
+	if ((size_t)dest_len < size)
+	{
+		ft_strncpy(&dest[dest_len], src, size - dest_len);
+		dest[size - 1] = '\0';
+	}
+	return (((size_t)dest_len < size) ? (size_t)(dest_len + ft_strlen(src))
+			: size + (size_t)ft_strlen(src));
+}