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

Dev (#2)

Browse Source 
* Restart from scratch

branched out on dev
removed all previous source files
started test on new env2lst function

* norm: splitted functions in main into appropriate file

Moved lstdelenvelem & env2lst to ms_env.c
Normed out files

* Feat(WIP): Added possibility to cmd_env to execute commands with
altered env.

Added dummy function for cd, echo, setenv & unsetenv
Started work on env copy feature

* feature: switched env from ft_list to specific list

* feature: added execution of commands from path

* feature: added env, setenv & unsetenv builtins

added -i option & command execution to env
added setenv & unsetenv builtins

* Clean-up: normed out files

* Changed comportment on error for check_path functions

* feature: added completion for ~ and ${}

WIP leaks detected on ${} completion

* fix leak on  ext need test

* feature: added echo cmd

changed printf ref to ft_printf

* feature: add cd built-in

* Simple norm-out

* moved env functions to libft

* fixed out-of-memory access in extension

* Resolved infinite loop in extension revolving

WIP norming in cd

* Normedout cmd_cd.c

* Normed out functions in cmd_cd

* Normed out funtions

sorting out needed

* removed -fsanitize from Makefile

* corrected env -i crash & SHLVL

* Delete norm.txt

* added put_error_cd2 in put_error_cd.c

* added inline environment
This commit is contained in:
tvdu29
2020-01-31 15:06:17 +01:00
committed by GitHub
parent 5247e0d8e6
commit 2a2f5bd4d3
146 changed files with 5802 additions and 772 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
.ccls Normal file
View File

@@ -0,0 +1,4 @@
clang
-Iincludes
-Ilibft/includes
%c %h -Wall -Wextra -Werror -g-Wall -Wextra -Werror -g

3
.gitmodules vendored
View File

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

118
Makefile
View File

@@ -5,45 +5,107 @@
# +:+ +:+ +:+ #
# By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ #
# Created: 2018/11/22 14:43:33 by tmaze #+# #+# #
# Updated: 2019/02/01 10:20:18 by tmaze ### ########.fr #
# Created: 2019/03/27 16:51:02 by tmaze #+# #+# #
# Updated: 2020/01/30 12:00:42 by tmaze ### ########.fr #
# #
#******************************************************************************#
CC := gcc
CCFLAGS := -Wall -Werror -Wextra -g
CCSTD :=
NAME = minishell
NAME := minishell
# Make options
MAKEFLAGS += --no-print-directory
SRCS := main.c exec.c cmd_echo.c cmd_cd.c cmd_env.c cmd_setenv.c cmd_unsetenv.c ms_env.c ms_env2.c
OBJS_DIR := objs
OBJS := $(SRCS:.c=.o)
INCLS := -Iincludes -Ilibft
LIBS := -Llibft -lft
# Output
UNAME := $(shell uname)
ifeq ($(UNAME), Darwin)
ECHO = @echo
endif
.PHONY = all clean fclean re
ifeq ($(UNAME), Linux)
ECHO = @echo -e
endif
all: $(NAME)
# Compilator
CC = gcc
FLAGS = -Wall -Wextra -Werror
$(NAME): $(OBJS) libft/libft.a
$(CC) $(CCFLAGS) $(CCSTD) $(INCLS) $(OBJS) -o $(NAME) $(LIBS)
# Folders
LIBDIR = libft
SRCDIR = srcs
OBJDIR = objs
INCDIR = includes libft/includes
%.o: srcs/%.c includes/minishell.h
$(CC) $(CCFLAGS) $(CCSTD) $(INCLS) -c $< -o $@
# Source files
SRC = main.c \
cmd_env.c \
cmd_setenv.c \
cmd_unsetenv.c \
cmd_cd.c \
cmd_echo.c \
ms_exec.c \
ms_ext.c \
put_error_cd.c
$(OBJS_DIR):
mkdir $(OBJS_DIR)
OBJ = $(SRC:.c=.o)
libft/libft.a:
$(MAKE) -Clibft all
LIB = ft
LIBFILE = libft.a
clean:
rm -rf $(OBJS)
$(MAKE) -Clibft clean
# Prefixes
OBJP = $(addprefix $(OBJDIR)/, $(SRC:.c=.o))
INCP = $(foreach dir, $(INCDIR), -I$(dir))
fclean: clean
rm -f $(NAME)
$(MAKE) -Clibft fclean
# Default Rule
DRULE = all
re: fclean all
# Main rules
default :
@$(ECHO) -e "$(PUR)===> $(GRE)$(NAME) : $(PUR) START RULE : $(DRULE) <===$(DEF)"
@make $(DRULE)
@$(ECHO) -e "$(PUR)===> $(GRE)$(NAME) : $(PUR) END RULE : $(DRULE) <===$(DEF)"
all : $(NAME)
# Compilation rules
$(OBJDIR)/%.o : $(SRCDIR)/%.c includes/minishell.h
@mkdir -p $(OBJDIR)
$(CC) $(FLAGS) -c -o $@ $< $(INCP)
$(LIBDIR)/$(LIBFILE) :
@$(ECHO) "$(YEL)===> $(GRE)$(NAME) : $(YEL) Librairy Compilation <===$(DEF)"
$(MAKE) -C $(LIBDIR) all
$(NAME) : $(OBJP) $(LIBDIR)/$(LIBFILE)
@$(ECHO) "$(YEL)===> $(GRE)$(NAME) : $(YEL) Binary Compilation <===$(DEF)"
$(CC) $(FLAGS) -o $@ $^ $(INCP) -L$(LIBDIR) -l$(LIB)
# Cleaner rules
clean :
@$(ECHO) "$(RED)===> $(GRE)$(NAME) : $(RED) Delete Object Files <===$(DEF)"
@$(RM) -rf $(OBJDIR)
@$(MAKE) -C $(LIBDIR) clean
fclean : clean
@$(ECHO) "$(RED)===> $(GRE)$(NAME) : $(RED) Delete Binary File <===$(DEF)"
@$(RM) -f $(NAME) $(NAME2)
@$(RM) -rf *.dSYM
@$(MAKE) -C $(LIBDIR) fclean
re : fclean default
# Phony
.PHONY = default all re clean fclean
# Color
DEF = \033[0m
BLA = \033[30m
BLI = \033[5m
BLU = \033[34m
CYA = \033[36m
GRA = \033[1m
GRE = \033[32m
PUR = \033[35m
RED = \033[31m
SOU = \033[4m
WHI = \033[37m
YEL = \033[33m

45
includes/minishell.h
View File

@@ -6,7 +6,7 @@
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/11/18 13:12:34 by tmaze #+# #+# */
/* Updated: 2019/02/01 10:19:53 by tmaze ### ########.fr */
/* Updated: 2020/01/26 22:19:25 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
@@ -17,37 +17,26 @@
# include <sys/stat.h>
# include "libft.h"
typedef struct s_builtin
# define S_BIN 5
typedef struct s_builtin
{
char *cmd;
int (*f)(char **argv, t_list **env);
} t_builtin;
char *cmd;
int (*f)(char **argv, t_env **env);
} t_builtin;
typedef struct s_envelem
{
char *key;
char *val;
} t_envelem;
int cmd_env(char **argv, t_env **env);
int cmd_setenv(char **argv, t_env **env);
int cmd_unsetenv(char **argv, t_env **env);
int cmd_cd(char **argv, t_env **env);
int cmd_echo(char **argv, t_env **env);
t_envelem *elem_new(char *key, char *val);
t_envelem *env_getelemfromkey(char *key, t_list *env);
t_envelem *env_addupdate(char *key, char *val, t_list **env);
void env_delelem(char *key, t_list **env);
char **res_ext(char **argv, t_env *env);
t_envelem *ft_envtoenvelem(char *env);
void ft_lstdelenvelem(void *content, size_t size);
void ft_envelemdel(t_envelem **env);
t_list *ft_envtolst(char **env);
int exec_cmd(char **argv, t_env **env);
void *ft_strdel_null(char **s);
int exec_cmd(char **argv, t_list **env);
int cmd_echo(char **argv, t_list **env);
int cmd_cd(char **argv, t_list **env);
int cmd_env(char **argv, t_list **env);
int cmd_setenv(char **argv, t_list **env);
int cmd_unsetenv(char **argv, t_list **env);
int ft_isin(char *str, char c);
char *check_path_slash(char *exec);
char *check_path_dot(char *exec, t_list *env);
void *put_error_cd(char *file, char *msg);
int put_error_cd2(char *file, char *msg);
#endif

1
libft

Submodule libft deleted from 4b44c49fc6

52
libft/.gitignore vendored Normal file
View File

@@ -0,0 +1,52 @@
# Prerequisites
*.d
# Object files
*.o
*.ko
*.obj
*.elf
# Linker output
*.ilk
*.map
*.exp
# Precompiled Headers
*.gch
*.pch
# Libraries
*.lib
*.a
*.la
*.lo
# Shared objects (inc. Windows DLLs)
*.dll
*.so
*.so.*
*.dylib
# Executables
*.exe
*.out
*.app
*.i*86
*.x86_64
*.hex
# Debug files
*.dSYM/
*.su
*.idb
*.pdb
# Kernel Module Compile Results
*.mod*
*.cmd
.tmp_versions/
modules.order
Module.symvers
Mkfile.old
dkms.conf

175
libft/Makefile Normal file
View File

@@ -0,0 +1,175 @@
#******************************************************************************#
# #
# ::: :::::::: #
# Makefile :+: :+: :+: #
# +:+ +:+ +:+ #
# By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ #
# Created: 2018/04/07 12:47:06 by tmaze #+# #+# #
# Updated: 2020/01/25 16:24:08 by tmaze ### ########.fr #
# #
#******************************************************************************#
CC = gcc
CCFLAGS = -Wall -Werror -Wextra
CCSTD =
NAME = libft.a
SRCS = ft_memalloc.c \
ft_memdel.c \
ft_memset.c \
ft_bzero.c \
ft_memcpy.c \
ft_memccpy.c \
ft_memmove.c \
ft_memchr.c \
ft_memcmp.c \
\
ft_isalpha.c \
ft_isdigit.c \
ft_isalnum.c \
ft_isascii.c \
ft_isprint.c \
ft_toupper.c \
ft_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 \
\
ft_envaddend.c \
ft_envclean.c \
ft_envdel.c \
ft_envdelelem.c \
ft_envgetelem.c \
ft_envnew.c \
ft_envtochar.c \
ft_envtotab.c \
ft_envupdate.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
libft/auteur Normal file
View File

@@ -0,0 +1 @@
tmaze

384
libft/includes/libft.h Normal file
View File

@@ -0,0 +1,384 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* libft.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/04/08 00:12:36 by tmaze #+# #+# */
/* Updated: 2019/12/06 09:57:17 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;
typedef struct s_env
{
char *key;
char *val;
struct s_env *next;
} t_env;
/*
** 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);
void ft_envdelelem(t_env **elem);
void ft_envdel(t_env **env);
t_env *ft_envnew(char *env);
t_env *ft_envaddend(t_env **alst, t_env *new);
t_env *ft_envgetelem(char *key, t_env *env);
char *ft_envtochar(t_env *env);
char **ft_envtotab(t_env *env);
void ft_envclean(t_env **env);
char *ft_envupdate(char *key, t_env *env, char *val);;
#endif

20
libft/srcs/ft_abs.c Normal file
View File

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

40
libft/srcs/ft_atoi.c Normal file
View File

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

41
libft/srcs/ft_atois.c Normal file
View File

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

18
libft/srcs/ft_bzero.c Normal file
View File

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

22
libft/srcs/ft_close.c Normal file
View File

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

24
libft/srcs/ft_del_words_tables.c Normal file
View File

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

31
libft/srcs/ft_envaddend.c Normal file
View File

@@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_envaddend.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/12/05 15:02:33 by tmaze #+# #+# */
/* Updated: 2019/12/09 13:00:42 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_env *ft_envaddend(t_env **alst, t_env *new)
{
t_env *tmp;
if (new == NULL)
return (NULL);
if (*alst == NULL)
*alst = new;
else
{
tmp = *alst;
while (tmp->next)
tmp = tmp->next;
tmp->next = new;
}
return (*alst);
}

32
libft/srcs/ft_envclean.c Normal file
View File

@@ -0,0 +1,32 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_envclean.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/12/06 09:53:25 by tmaze #+# #+# */
/* Updated: 2019/12/06 09:53:47 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_envclean(t_env **env)
{
t_env **it;
t_env *tmp;
it = env;
while (*it)
{
if (ft_strequ((*it)->val, ""))
{
tmp = *it;
*it = tmp->next;
ft_envdelelem(&tmp);
}
else
it = &((*it)->next);
}
}

25
libft/srcs/ft_envdel.c Normal file
View File

@@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_envdel.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/12/05 14:51:20 by tmaze #+# #+# */
/* Updated: 2019/12/09 13:00:46 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_envdel(t_env **env)
{
t_env *tmp;
while (*env)
{
tmp = *env;
*env = (*env)->next;
ft_envdelelem(&tmp);
}
}

23
libft/srcs/ft_envdelelem.c Normal file
View File

@@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_envdelelem.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/12/05 14:43:45 by tmaze #+# #+# */
/* Updated: 2019/12/09 13:00:45 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_envdelelem(t_env **elem)
{
if (elem)
{
ft_strdel(&((*elem)->key));
ft_strdel(&((*elem)->val));
ft_memdel((void**)elem);
}
}

23
libft/srcs/ft_envgetelem.c Normal file
View File

@@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_envgetelem.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/12/05 16:46:17 by tmaze #+# #+# */
/* Updated: 2019/12/05 16:47:00 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_env *ft_envgetelem(char *key, t_env *env)
{
t_env *it;
it = env;
while (it && !ft_strequ(it->key, key))
it = it->next;
return (it);
}

29
libft/srcs/ft_envnew.c Normal file
View File

@@ -0,0 +1,29 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_envnew.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/12/05 14:54:55 by tmaze #+# #+# */
/* Updated: 2019/12/05 17:12:59 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_env *ft_envnew(char *env)
{
t_env *ret;
int i;
i = 0;
ret = NULL;
while (env[i] && env[i] != '=')
i++;
if (env[i] == '=' && (ret = (t_env*)ft_memalloc(sizeof(t_env))) != NULL)
if ((ret->val = ft_strsub(env, i + 1, ft_strlen(env) - i - 1)) == NULL
|| (ret->key = ft_strsub(env, 0, i)) == NULL)
ft_envdelelem(&ret);
return (ret);
}

28
libft/srcs/ft_envtochar.c Normal file
View File

@@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_envtochar.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/12/05 17:28:25 by tmaze #+# #+# */
/* Updated: 2019/12/09 13:00:44 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_envtochar(t_env *env)
{
int size;
char *ret;
size = ft_strlen(env->key) + ft_strlen(env->val) + 2;
if ((ret = ft_strnew(size)) != NULL)
{
ft_strlcpy(ret, env->key, size);
ft_strlcat(ret, "=", size);
ft_strlcat(ret, env->val, size);
}
return (ret);
}

41
libft/srcs/ft_envtotab.c Normal file
View File

@@ -0,0 +1,41 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_envtotab.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/12/05 17:34:22 by tmaze #+# #+# */
/* Updated: 2019/12/05 17:34:41 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char **ft_envtotab(t_env *env)
{
t_env *it;
char *new;
char **ret;
int i;
i = 0;
ret = NULL;
it = env;
while (it && (++i))
it = it->next;
if ((ret = (char**)ft_memalloc(sizeof(char*) * (i + 1))) == NULL)
return (NULL);
it = env;
i = 0;
while (it)
{
if ((new = ft_envtochar(it)) == NULL)
ft_del_words_tables(&ret);
if (new == NULL)
break ;
ret[i++] = new;
it = it->next;
}
return (ret);
}

28
libft/srcs/ft_envupdate.c Normal file
View File

@@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_envupdate.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/12/05 19:10:38 by tmaze #+# #+# */
/* Updated: 2019/12/05 19:10:52 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_envupdate(char *key, t_env *env, char *val)
{
t_env *elem;
char *new;
new = NULL;
if ((elem = ft_envgetelem(key, env)) != NULL)
if ((new = ft_strdup(val)) != NULL)
{
ft_strdel(&elem->val);
elem->val = new;
}
return (new);
}

87
libft/srcs/ft_getline.c Normal file
View File

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

13
libft/srcs/ft_gets.c Normal file
View File

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

23
libft/srcs/ft_hasdigit.c Normal file
View File

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

18
libft/srcs/ft_isalnum.c Normal file
View File

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

18
libft/srcs/ft_isalpha.c Normal file
View File

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

18
libft/srcs/ft_isascii.c Normal file
View File

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

18
libft/srcs/ft_isdigit.c Normal file
View File

@@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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
libft/srcs/ft_islower.c Normal file
View File

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

18
libft/srcs/ft_isprint.c Normal file
View File

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

18
libft/srcs/ft_issign.c Normal file
View File

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

18
libft/srcs/ft_isupper.c Normal file
View File

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

19
libft/srcs/ft_iswhitespace.c Normal file
View File

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

41
libft/srcs/ft_itoa.c Normal file
View File

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

19
libft/srcs/ft_lstadd.c Normal file
View File

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

29
libft/srcs/ft_lstaddend.c Normal file
View File

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

31
libft/srcs/ft_lstaddsort.c Normal file
View File

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

23
libft/srcs/ft_lstdel.c Normal file
View File

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

20
libft/srcs/ft_lstdelone.c Normal file
View File

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

28
libft/srcs/ft_lstgetat.c Normal file
View File

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

18
libft/srcs/ft_lstgetlast.c Normal file
View File

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

25
libft/srcs/ft_lstiter.c Normal file
View File

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

37
libft/srcs/ft_lstmap.c Normal file
View File

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

39
libft/srcs/ft_lstnew.c Normal file
View File

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

21
libft/srcs/ft_lstsize.c Normal file
View File

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

30
libft/srcs/ft_lstsort.c Normal file
View File

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

22
libft/srcs/ft_memalloc.c Normal file
View File

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

27
libft/srcs/ft_memccpy.c Normal file
View File

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

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

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

31
libft/srcs/ft_memcmp.c Normal file
View File

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

23
libft/srcs/ft_memcpy.c Normal file
View File

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

22
libft/srcs/ft_memdel.c Normal file
View File

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

30
libft/srcs/ft_memmove.c Normal file
View File

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

23
libft/srcs/ft_memset.c Normal file
View File

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

30
libft/srcs/ft_nbrlen.c Normal file
View File

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

28
libft/srcs/ft_open.c Normal file
View File

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

25
libft/srcs/ft_print_words_tables.c Normal file
View File

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

91
libft/srcs/ft_printf.c Normal file
View File

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

142
libft/srcs/ft_printf_check_fields.c Normal file
View File

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

69
libft/srcs/ft_printf_check_type.c Normal file
View File

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

49
libft/srcs/ft_printf_tools.c Normal file
View File

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

30
libft/srcs/ft_printf_tools_char.c Normal file
View File

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

122
libft/srcs/ft_printf_tools_float.c Normal file
View File

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

120
libft/srcs/ft_printf_tools_hexa.c Normal file
View File

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

113
libft/srcs/ft_printf_tools_int.c Normal file
View File

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

50
libft/srcs/ft_printf_tools_lenght.c Normal file
View File

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

79
libft/srcs/ft_printf_tools_malloc_size.c Normal file
View File

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

110
libft/srcs/ft_printf_tools_oct.c Normal file
View File

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

97
libft/srcs/ft_printf_tools_prec_size.c Normal file
View File

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

64
libft/srcs/ft_printf_tools_str.c Normal file
View File

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

99
libft/srcs/ft_printf_tools_unsigned_int.c Normal file
View File

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

109
libft/srcs/ft_printf_tools_wchar_t.c Normal file
View File

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

89
libft/srcs/ft_printf_tools_wstr.c Normal file
View File

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

18
libft/srcs/ft_putchar.c Normal file
View File

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

18
libft/srcs/ft_putchar_fd.c Normal file
View File

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

20
libft/srcs/ft_putendl.c Normal file
View File

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

28
libft/srcs/ft_putendl2.c Normal file
View File

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

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

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

28
libft/srcs/ft_putendl_fd2.c Normal file
View File

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

18
libft/srcs/ft_putnbr.c Normal file
View File

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

33
libft/srcs/ft_putnbr_fd.c Normal file
View File

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

24
libft/srcs/ft_putnbrpad.c Normal file
View File

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

19
libft/srcs/ft_putstr.c Normal file
View File

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

19
libft/srcs/ft_putstr_fd.c Normal file
View File

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

24
libft/srcs/ft_putstrn.c Normal file
View File

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

24
libft/srcs/ft_putstrpad.c Normal file
View File

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

77
libft/srcs/ft_realpath.c Normal file
View File

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

20
libft/srcs/ft_round.c Normal file
View File

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

32
libft/srcs/ft_sort_params.c Normal file
View File

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

24
libft/srcs/ft_str_is_alpha.c Normal file
View File

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

24
libft/srcs/ft_str_is_lowercase.c Normal file
View File

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

24
libft/srcs/ft_str_is_numeric.c Normal file
View File

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

24
libft/srcs/ft_str_is_printable.c Normal file
View File

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

24
libft/srcs/ft_str_is_uppercase.c Normal file
View File

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

29
libft/srcs/ft_strcapitalize.c Normal file
View File

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

22
libft/srcs/ft_strcat.c Normal file
View File

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

29
libft/srcs/ft_strchr.c Normal file
View File

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

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