tvdu29/lem_in
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Compare commits

merge into: tvdu29:Mthandazo42
Branches Tags
tvdu29:master tvdu29:tmaze tvdu29:Mthandazo42
...
pull from: tvdu29:tmaze
Branches Tags
tvdu29:master tvdu29:tmaze tvdu29:Mthandazo42

19 Commits
Mthandazo4 ... tmaze

Author SHA1 Message Date
Tanguy MAZE
dd255666f1 started work to redo algorithm 
branch out to redo algorithm
 2019-04-15 18:05:25 +02:00
Tanguy MAZE
4a5c798b25 rework on score system 
need to score with correct amount of ants on each paths
also secured ft_atois
 2019-04-14 14:45:38 +02:00
Tanguy MAZE
9b75432c2e Added scoring system to algorithm 
still need testing and optimisations
not norm-compliant
 2019-04-13 14:56:39 +02:00
Tanguy MAZE
d85e0873cb added protection on double pipes 2019-04-11 22:34:35 +02:00
Mthandazo Ndhlovu
0495ba9e55 clean up code for when an error occurs 
testing with all maps is what is left
 2019-04-11 14:11:25 +02:00
Mthandazo Ndhlovu
eb85b914a4 Leaks and error checking almost done 
function to clean traces of holder is done.
Error checking before adjacency list creation is done also.
Now focusing on breaking the parser with
invalid maps. It should be ready in a day.
 2019-04-11 12:52:14 +02:00
Tanguy MAZE
86b0530bf7 clean up still in progress 
eliminated most of the leaks of the parser
norming still need to be done
 2019-04-11 11:40:26 +02:00
Tanguy MAZE
8c4a6aac25 a bit more of normalising 
normalising lem_in WIP
 2019-04-10 15:35:23 +02:00
Tanguy MAZE
5d094ebcaf Massive clean up 
cleaned up unused code
normalised push_ants
libft is no longer a submodule
still need to normalise lem_in
 2019-04-10 14:34:59 +02:00
Tanguy MAZE
fb66233265 sry =S 
forgot 3 files in last commitP
 2019-04-09 19:10:47 +02:00
Tanguy MAZE
3b893147e5 IT WORKS ! 
functionning ./lem_in that can read maps and display ants path
still need to clean leaks
still need remove debug info
 2019-04-09 19:09:29 +02:00
Tanguy MAZE
434b629055 better featured API for t_lmdata adj 
added function to help create and clear the adjacency list
 2019-04-09 14:36:30 +02:00
Tanguy MAZE
08e622a4f0 a bit of management 
added push_ants in its own file
 2019-04-08 19:18:56 +02:00
Tanguy MAZE
a2fd180398 some light work today 
corrected invalid read in update_weights() when tab[i].parent was
equal to -1
 2019-04-07 12:51:40 +02:00
Tanguy MAZE
ae93873452 push_ants done need to test 
done all mechanism to display ants moving in the graph
still need testing
still need norming
 2019-04-06 14:03:22 +02:00
Tanguy MAZE
c36f501b08 testing things 
thinking of how to display the ants moving and optimise by moving at
least one on each path
 2019-04-05 17:43:17 +02:00
Tanguy MAZE
0a9d7b816d Merge branch 'tmaze' 
merging algorithm to master of project
 2019-04-05 14:06:42 +02:00
Tanguy MAZE
ea0eda89d0 aaaaaaand it's done ! 
algorithm finished and normed
more testing might be needed
 2019-04-03 17:20:29 +02:00
Tanguy MAZE
15669b7402 not quite there yet but nearly ^^ 
WIP for the algorithm not to pass on previously used node
 2019-04-01 19:06:19 +02:00
139 changed files with 922 additions and 5225 deletions
Expand all files Collapse all files

3
.gitmodules vendored
View File

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

24
Makefile
View File

@@ -6,11 +6,11 @@
# By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ #
# Created: 2019/03/27 16:51:02 by tmaze #+# #+# #
# Updated: 2019/03/31 19:48:45 by tmaze ### ########.fr #
# Updated: 2019/04/15 17:03:17 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 -O0 -fsanitize=address
FLAGS = -Wall -Wextra -Werror -g
# Folders
LIBDIR = libft
@@ -36,7 +36,23 @@ OBJDIR = objs
INCDIR = includes libft/includes
# Source files
SRC = lem_in.c lm_parser.c lm_mem_utils.c lm_graph_utils.c lm_check_errors.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 \
bfs.c \
lst_ind.c \
edmunds_karp.c \
push_ants.c \
push_ants_utils.c \
score_utils.c \
lem_in.c
OBJ = $(SRC:.c=.o)

BIN
Oglibft/.DS_Store vendored
View File

Binary file not shown.

165
Oglibft/libft/Makefile
View File

@@ -1,165 +0,0 @@
#******************************************************************************#
# #
# ::: :::::::: #
# Makefile :+: :+: :+: #
# +:+ +:+ +:+ #
# By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ #
# Created: 2018/04/07 12:47:06 by tmaze #+# #+# #
# Updated: 2019/03/27 17:46:28 by tmaze ### ########.fr #
# #
#******************************************************************************#
CC = gcc
CCFLAGS = -Wall -Werror -Wextra -g -O0 -fsanitize=address
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_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

1
Oglibft/libft/auteur
View File

@@ -1 +0,0 @@
tmaze

367
Oglibft/libft/includes/libft.h
View File

@@ -1,367 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* libft.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/04/08 00:12:36 by tmaze #+# #+# */
/* Updated: 2019/03/20 16:46:41 by tmaze ### ########.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_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

20
Oglibft/libft/srcs/ft_abs.c
View File

@@ -1,20 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

40
Oglibft/libft/srcs/ft_atoi.c
View File

@@ -1,40 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

41
Oglibft/libft/srcs/ft_atois.c
View File

@@ -1,41 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

18
Oglibft/libft/srcs/ft_bzero.c
View File

@@ -1,18 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

22
Oglibft/libft/srcs/ft_close.c
View File

@@ -1,22 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

24
Oglibft/libft/srcs/ft_del_words_tables.c
View File

@@ -1,24 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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;
}

87
Oglibft/libft/srcs/ft_getline.c
View File

@@ -1,87 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

13
Oglibft/libft/srcs/ft_gets.c
View File

@@ -1,13 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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"

23
Oglibft/libft/srcs/ft_hasdigit.c
View File

@@ -1,23 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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]));
}

18
Oglibft/libft/srcs/ft_isalnum.c
View File

@@ -1,18 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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));
}

18
Oglibft/libft/srcs/ft_isalpha.c
View File

@@ -1,18 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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));
}

18
Oglibft/libft/srcs/ft_isascii.c
View File

@@ -1,18 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

18
Oglibft/libft/srcs/ft_isdigit.c
View File

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

18
Oglibft/libft/srcs/ft_islower.c
View File

@@ -1,18 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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');
}

18
Oglibft/libft/srcs/ft_isprint.c
View File

@@ -1,18 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

18
Oglibft/libft/srcs/ft_issign.c
View File

@@ -1,18 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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 == '-');
}

18
Oglibft/libft/srcs/ft_isupper.c
View File

@@ -1,18 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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');
}

19
Oglibft/libft/srcs/ft_iswhitespace.c
View File

@@ -1,19 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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');
}

41
Oglibft/libft/srcs/ft_itoa.c
View File

@@ -1,41 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

19
Oglibft/libft/srcs/ft_lstadd.c
View File

@@ -1,19 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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;
}

29
Oglibft/libft/srcs/ft_lstaddend.c
View File

@@ -1,29 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

31
Oglibft/libft/srcs/ft_lstaddsort.c
View File

@@ -1,31 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}
}

23
Oglibft/libft/srcs/ft_lstdel.c
View File

@@ -1,23 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}
}

20
Oglibft/libft/srcs/ft_lstdelone.c
View File

@@ -1,20 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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;
}

28
Oglibft/libft/srcs/ft_lstgetat.c
View File

@@ -1,28 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

18
Oglibft/libft/srcs/ft_lstgetlast.c
View File

@@ -1,18 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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));
}

25
Oglibft/libft/srcs/ft_lstiter.c
View File

@@ -1,25 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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;
}
}

37
Oglibft/libft/srcs/ft_lstmap.c
View File

@@ -1,37 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

39
Oglibft/libft/srcs/ft_lstnew.c
View File

@@ -1,39 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

21
Oglibft/libft/srcs/ft_lstsize.c
View File

@@ -1,21 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

30
Oglibft/libft/srcs/ft_lstsort.c
View File

@@ -1,30 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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;
}

22
Oglibft/libft/srcs/ft_memalloc.c
View File

@@ -1,22 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

27
Oglibft/libft/srcs/ft_memccpy.c
View File

@@ -1,27 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

26
Oglibft/libft/srcs/ft_memchr.c
View File

@@ -1,26 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

31
Oglibft/libft/srcs/ft_memcmp.c
View File

@@ -1,31 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

23
Oglibft/libft/srcs/ft_memcpy.c
View File

@@ -1,23 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

22
Oglibft/libft/srcs/ft_memdel.c
View File

@@ -1,22 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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;
}
}

30
Oglibft/libft/srcs/ft_memmove.c
View File

@@ -1,30 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

23
Oglibft/libft/srcs/ft_memset.c
View File

@@ -1,23 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

30
Oglibft/libft/srcs/ft_nbrlen.c
View File

@@ -1,30 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

28
Oglibft/libft/srcs/ft_open.c
View File

@@ -1,28 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

25
Oglibft/libft/srcs/ft_print_words_tables.c
View File

@@ -1,25 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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++;
}
}

91
Oglibft/libft/srcs/ft_printf.c
View File

@@ -1,91 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

142
Oglibft/libft/srcs/ft_printf_check_fields.c
View File

@@ -1,142 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

69
Oglibft/libft/srcs/ft_printf_check_type.c
View File

@@ -1,69 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

49
Oglibft/libft/srcs/ft_printf_tools.c
View File

@@ -1,49 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

30
Oglibft/libft/srcs/ft_printf_tools_char.c
View File

@@ -1,30 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

122
Oglibft/libft/srcs/ft_printf_tools_float.c
View File

@@ -1,122 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

120
Oglibft/libft/srcs/ft_printf_tools_hexa.c
View File

@@ -1,120 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

113
Oglibft/libft/srcs/ft_printf_tools_int.c
View File

@@ -1,113 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

50
Oglibft/libft/srcs/ft_printf_tools_lenght.c
View File

@@ -1,50 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

79
Oglibft/libft/srcs/ft_printf_tools_malloc_size.c
View File

@@ -1,79 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

110
Oglibft/libft/srcs/ft_printf_tools_oct.c
View File

@@ -1,110 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

97
Oglibft/libft/srcs/ft_printf_tools_prec_size.c
View File

@@ -1,97 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

64
Oglibft/libft/srcs/ft_printf_tools_str.c
View File

@@ -1,64 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

99
Oglibft/libft/srcs/ft_printf_tools_unsigned_int.c
View File

@@ -1,99 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

109
Oglibft/libft/srcs/ft_printf_tools_wchar_t.c
View File

@@ -1,109 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

89
Oglibft/libft/srcs/ft_printf_tools_wstr.c
View File

@@ -1,89 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

18
Oglibft/libft/srcs/ft_putchar.c
View File

@@ -1,18 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

18
Oglibft/libft/srcs/ft_putchar_fd.c
View File

@@ -1,18 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

20
Oglibft/libft/srcs/ft_putendl.c
View File

@@ -1,20 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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');
}

28
Oglibft/libft/srcs/ft_putendl2.c
View File

@@ -1,28 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

22
Oglibft/libft/srcs/ft_putendl_fd.c
View File

@@ -1,22 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}
}

28
Oglibft/libft/srcs/ft_putendl_fd2.c
View File

@@ -1,28 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

18
Oglibft/libft/srcs/ft_putnbr.c
View File

@@ -1,18 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

33
Oglibft/libft/srcs/ft_putnbr_fd.c
View File

@@ -1,33 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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;
}
}

24
Oglibft/libft/srcs/ft_putnbrpad.c
View File

@@ -1,24 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

19
Oglibft/libft/srcs/ft_putstr.c
View File

@@ -1,19 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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));
}

19
Oglibft/libft/srcs/ft_putstr_fd.c
View File

@@ -1,19 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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));
}

24
Oglibft/libft/srcs/ft_putstrn.c
View File

@@ -1,24 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}
}

24
Oglibft/libft/srcs/ft_putstrpad.c
View File

@@ -1,24 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

77
Oglibft/libft/srcs/ft_realpath.c
View File

@@ -1,77 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

20
Oglibft/libft/srcs/ft_round.c
View File

@@ -1,20 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

32
Oglibft/libft/srcs/ft_sort_params.c
View File

@@ -1,32 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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;
}
}

24
Oglibft/libft/srcs/ft_str_is_alpha.c
View File

@@ -1,24 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

24
Oglibft/libft/srcs/ft_str_is_lowercase.c
View File

@@ -1,24 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

24
Oglibft/libft/srcs/ft_str_is_numeric.c
View File

@@ -1,24 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

24
Oglibft/libft/srcs/ft_str_is_printable.c
View File

@@ -1,24 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

24
Oglibft/libft/srcs/ft_str_is_uppercase.c
View File

@@ -1,24 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

29
Oglibft/libft/srcs/ft_strcapitalize.c
View File

@@ -1,29 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

22
Oglibft/libft/srcs/ft_strcat.c
View File

@@ -1,22 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

29
Oglibft/libft/srcs/ft_strchr.c
View File

@@ -1,29 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

23
Oglibft/libft/srcs/ft_strclr.c
View File

@@ -1,23 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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';
}

28
Oglibft/libft/srcs/ft_strcmp.c
View File

@@ -1,28 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strcmp.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/04/03 15:38:27 by tmaze #+# #+# */
/* Updated: 2018/04/08 15:30:24 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_strcmp(const char *s1, const char *s2)
{
int i;
int diff;
i = 1;
diff = (unsigned char)s1[0] - (unsigned char)s2[0];
while (diff == 0 && s1[i - 1] && s2[i - 1])
{
diff = (unsigned char)s1[i] - (unsigned char)s2[i];
i++;
}
return (diff);
}

23
Oglibft/libft/srcs/ft_strcpy.c
View File

@@ -1,23 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

18
Oglibft/libft/srcs/ft_strdel.c
View File

@@ -1,18 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

22
Oglibft/libft/srcs/ft_strdup.c
View File

@@ -1,22 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

18
Oglibft/libft/srcs/ft_strequ.c
View File

@@ -1,18 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

23
Oglibft/libft/srcs/ft_striter.c
View File

@@ -1,23 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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++]);
}

23
Oglibft/libft/srcs/ft_striteri.c
View File

@@ -1,23 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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]);
}

27
Oglibft/libft/srcs/ft_strjoin.c
View File

@@ -1,27 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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);
}

27
Oglibft/libft/srcs/ft_strlcat.c
View File

@@ -1,27 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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));
}

26
Oglibft/libft/srcs/ft_strlcpy.c
View File

@@ -1,26 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlcpy.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/04/09 11:55:11 by tmaze #+# #+# */
/* Updated: 2018/04/27 18:04:14 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
size_t ft_strlcpy(char *dst, const char *src, size_t size)
{
size_t src_len;
if (dst != NULL && src != NULL)
{
src_len = (size_t)ft_strlen(src);
dst = ft_strncpy(dst, src, (src_len > size) ? size : src_len);
dst[(src_len > size) ? size - 1 : src_len] = '\0';
}
return ((src != NULL) ? ft_strlen(src) : 0);
}

23
Oglibft/libft/srcs/ft_strlen.c
View File

@@ -1,23 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlen.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/04/03 15:33:37 by tmaze #+# #+# */
/* Updated: 2018/05/16 15:33:46 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
size_t ft_strlen(const char *s)
{
int i;
i = 0;
while (s != NULL && s[i])
i++;
return (i);
}

Some files were not shown because too many files have changed in this diff Show More