jack/42-archive
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge ls with full history

Browse source
This commit is contained in:
Jack 2026-01-29 18:04:48 -03:00
commit f0193ee652
No known key found for this signature in database
181 changed files with 6435 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
ls/.gitignore vendored Normal file
View file

@ -0,0 +1,2 @@
ft_ls
tests

45
ls/Makefile Normal file
View file

@ -0,0 +1,45 @@
NAME = ft_ls
CC = gcc
D_SRC = src
F_SRC := $(shell ls -1 $(D_SRC) | grep "\.c$$")
F_SRC := ft_dir_get_ents.c ft_ent_free.c ft_ent_get_dirs.c ft_ent_has_dir.c ft_ls.c ft_ls_color.c ft_ls_long.c ft_ls_postname.c ft_ls_short.c lib_ent.c lib_error.c lib_ls_long.c lib_ls_long2.c lib_lsdata.c lib_parse.c lib_time.c main.c
DF_SRC := $(addprefix $(D_SRC)/, $(F_SRC))
D_OBJ = obj
F_OBJ = $(F_SRC:.c=.o)
DF_OBJ := $(addprefix $(D_OBJ)/, $(F_OBJ))
D_INC = includes libft/includes
O_INC = $(addprefix -I, $(D_INC))
W_FLAGS = -Wall -Wextra -Werror
D_FLAGS =
MKDIR = mkdir -p
RM = /bin/rm -rf
.PHONY: all clean fclean re
all: $(NAME)
$(D_OBJ)/%.o: $(D_SRC)/%.c $(D_INC)
@$(MKDIR) $(D_OBJ)
@$(CC) $(O_INC) $(W_FLAGS) -c $< -o $@ $(D_FLAGS)
@echo "Compiling "$<"..."
libft/libft.a:
@$(MAKE) -C libft/ 2>/dev/null
$(NAME): libft/libft.a $(DF_OBJ)
$(CC) $(O_INC) -Llibft -lft $(W_FLAGS) $(DF_OBJ) -o $@ $(D_FLAGS)
clean:
$(RM) $(D_OBJ)
@$(MAKE) -C libft clean 2>/dev/null
fclean: clean
$(RM) $(NAME)
@$(MAKE) -C libft fclean 2>/dev/null
re: fclean all

110
ls/README.md Normal file
View file

@ -0,0 +1,110 @@
# ft_ls -- list directory contents
## SYNOPSIS
ft_ls [-AFGRUSTacdfgloprtu1] [file ...]
## DESCRIPTION
For each operand that names a file of a type other than directory, ls displays its name as well as any requested, associated information. For each operand that names a file of type
directory, ls displays the names of files contained within that directory, as well as any requested, associated information.
If no operands are given, the contents of the current directory are displayed. If more than one operand is given, non-directory operands are displayed first; directory and non-
directory operands are sorted separately and in lexicographical order.
The following options are available:
-1 (The numeric digit ``one''.) Force output to be one entry per line. This is the default when output is not to a terminal.
-A List all entries except for . and ... Always set for the super-user.
-a Include directory entries whose names begin with a dot (.).
-d Directories are listed as plain files (not searched recursively).
-F Display a slash (`/') immediately after each pathname that is a directory, an asterisk (`*') after each that is executable, an at sign (`@') after each symbolic link, an
equals sign (`=') after each socket, a percent sign (`%') after each whiteout, and a vertical bar (`|') after each that is a FIFO.
-f Output is not sorted. This option turns on the -a option.
-G Enable colorized output. This option is equivalent to defining CLICOLOR in the environment. (See below.)
-g This option is only available for compatibility with POSIX; it is used to display the group name in the long (-l) format output (the owner name is suppressed).
-l (The lowercase letter ``ell''.) List in long format. (See below.) If the output is to a terminal, a total sum for all the file sizes is output on a line before the long
listing.
-o List in long format, but omit the group id.
-p Write a slash (`/') after each filename if that file is a directory.
-R Recursively list subdirectories encountered.
-r Reverse the order of the sort to get reverse lexicographical order or the oldest entries first (or largest files last, if combined with sort by size
-S Sort files by size
-s Display the number of file system blocks actually used by each file, in units of 512 bytes, where partial units are rounded up to the next integer value. If the output is to
a terminal, a total sum for all the file sizes is output on a line before the listing. The environment variable BLOCKSIZE overrides the unit size of 512 bytes.
-T When used with the -l (lowercase letter ``ell'') option, display complete time information for the file, including month, day, hour, minute, second, and year.
-t Sort by time modified (most recently modified first) before sorting the operands by lexicographical order.
-u Use time of last access, instead of last modification of the file for sorting (-t) or long printing (-l).
-U Use time of file creation, instead of last modification for sorting (-t) or long output (-l).
### The Long Format
If the -l option is given, the following information is displayed for each file: file mode, number of links, owner name, group name, number of bytes in the file, abbreviated month,
day-of-month file was last modified, hour file last modified, minute file last modified, and the pathname. In addition, for each directory whose contents are displayed, the total
number of 512-byte blocks used by the files in the directory is displayed on a line by itself, immediately before the information for the files in the directory. If the file or
directory has extended attributes, the permissions field printed by the -l option is followed by a '@' character. Otherwise, if the file or directory has extended security informa-
tion (such as an access control list), the permissions field printed by the -l option is followed by a '+' character.
If the modification time of the file is more than 6 months in the past or future, then the year of the last modification is displayed in place of the hour and minute fields.
If the owner or group names are not a known user or group name, or the -n option is given, the numeric ID's are displayed.
If the file is a character special or block special file, the major and minor device numbers for the file are displayed in the size field. If the file is a symbolic link, the path-
name of the linked-to file is preceded by ``->''.
The file mode printed under the -l option consists of the entry type, owner permissions, and group permissions. The entry type character describes the type of file, as follows:
b Block special file.
c Character special file.
d Directory.
l Symbolic link.
s Socket link.
p FIFO.
- Regular file.
The next three fields are three characters each: owner permissions, group permissions, and other permissions. Each field has three character positions:
1. If r, the file is readable; if -, it is not readable.
2. If w, the file is writable; if -, it is not writable.
3. The first of the following that applies:
S If in the owner permissions, the file is not executable and set-user-ID mode is set. If in the group permissions, the file is not executable and set-group-ID
mode is set.
s If in the owner permissions, the file is executable and set-user-ID mode is set. If in the group permissions, the file is executable and setgroup-ID mode is
set.
x The file is executable or the directory is searchable.
- The file is neither readable, writable, executable, nor set-user-ID nor set-group-ID mode, nor sticky. (See below.)
These next two apply only to the third character in the last group (other permissions).
T The sticky bit is set (mode 1000), but not execute or search permission. (See chmod(1) or sticky(8).)
t The sticky bit is set (mode 1000), and is searchable or executable. (See chmod(1) or sticky(8).)
## EXAMPLES
The following is how to do an ls listing sorted by increasing size
./ft_ls -lrS
## DIAGNOSTICS
The ft_ls utility exits 0 on success, and >0 if an error occurs.

1
ls/auteur Normal file
View file

@ -0,0 +1 @@
jhalford

137
ls/includes/ft_ls.h Normal file
View file

@ -0,0 +1,137 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ftls.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 15:10:03 by jhalford #+# #+# */
/* Updated: 2016/11/27 13:09:06 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef FT_LS_H
# define FT_LS_H
# define LS_LEGAL_OPTS "AFGRUSTacdfgloprtu1"
# define LS_MSG_ILLEGAL_OPT "ft_ls: illegal option -- %c\n"
# define LS_MSG_USAGE "usage: ls [-%s] [file ...]\n"
# define LS_MSG_FILE_ERR "ls: %s: No such file or directory\n"
# define LS_MSG_ACC_ERR "ls: %s: Permission denied\n"
# ifndef S_IXUGO
# define S_IXUGO (S_IXUSR | S_IXGRP | S_IXOTH)
# endif
# define OPTS_LA 0x00000001
# define OPTS_LC 0x00000002
# define OPTS_LD 0x00000004
# define OPTS_LF 0x00000008
# define OPTS_LG 0x00000010
# define OPTS_LL 0x00000020
# define OPTS_LO 0x00000040
# define OPTS_LP 0x00000080
# define OPTS_LR 0x00000100
# define OPTS_LT 0x00000200
# define OPTS_LU 0x00000400
# define OPTS_UA 0x00000800
# define OPTS_UF 0x00001000
# define OPTS_UG 0x00002000
# define OPTS_UR 0x00004000
# define OPTS_UU 0x00008000
# define OPTS_US 0x00010000
# define OPTS_UT 0x00020000
# define OPTS_ONE 0x00040000
# define OPTS_ERR_A 0x00100000
# define OPTS_HEAD 0x01000000
# define TIME_MASK (OPTS_LC | OPTS_LU | OPTS_UU)
# include "libft.h"
# include <errno.h>
# include <stdio.h>
# include <dirent.h>
# include <sys/stat.h>
# include <sys/types.h>
# include <pwd.h>
# include <grp.h>
# include <sys/acl.h>
struct s_lsdata
{
struct stat stat;
char *path;
struct dirent *dirent;
};
struct s_pads
{
int nlink;
int name;
int gr_name;
int size;
int major;
int minor;
};
struct s_opts
{
char id;
int on;
int off;
};
typedef struct s_lsdata t_lsdata;
typedef struct s_pads t_pads;
typedef struct s_opts t_opts;
extern t_opts g_opts[];
int ft_ls_parse(int ac, char **av, t_list **dir, t_list **ent);
void ft_ls_dirs(t_list *dir, int opts);
void ft_ls_files(t_list **ent, t_list **dir, t_lsdata *topdir, int *opts);
int ft_cmp_mtime(t_lsdata *dat1, t_lsdata *dat2);
int ft_cmp_atime(t_lsdata *dat1, t_lsdata *dat2);
int ft_cmp_ctime(t_lsdata *dat1, t_lsdata *dat2);
int ft_cmp_btime(t_lsdata *dat1, t_lsdata *dat2);
void ft_ls_postname(mode_t m, int opts);
void ft_lsdata_filename(t_lsdata *data, t_lsdata *topdir, int opts);
int ft_lsdata_cmp_name(t_lsdata *dat1, t_lsdata *dat2);
int ft_lsdata_cmp_size(t_lsdata *dat1, t_lsdata *dat2);
int ft_lsdata_cmp0(t_lsdata *dat1, char *dataref);
int ft_lsdata_cmpa(t_lsdata *data, char *dataref);
void ft_ent_filter(t_list **ent, int opts);
void ft_ent_sort(t_list **ent, int opts);
void ft_ent_print(
t_list *ent, int *opts, t_lsdata *topdir, t_list *nextdir);
int ft_ent_has_dir(t_list *ent);
t_list *ft_ent_get_dirs(t_list **ent);
void ft_ent_free(void *ptr, size_t size);
t_list *ft_dir_get_ents(t_lsdata *topdir, int *opts);
void ft_ls_short(t_list *ent, t_lsdata *topdir, int opts);
int ft_ls_long(t_list *ent, t_lsdata *topdir, int opts);
int ft_ls_long_print(t_list *ent, t_lsdata *topdir, t_pads pads, int opts);
void ft_ls_long_total(t_list *ent);
int ft_ls_long_pads(t_list *ent, t_pads *pads);
void ft_ls_long_type(mode_t m);
void ft_ls_long_rights(mode_t m);
int ft_ls_long_xattr(mode_t m, char *path);
int ft_ls_long_middle(struct stat *stat, t_pads *pads, int opts);
void ft_ls_long_date(struct stat *stat, int opts);
int ft_ls_long_lnk(t_lsdata *data);
void ft_error_option(char c);
void ft_error_dir(char *s);
void ft_error_access(char *s);
void ft_ls_color(mode_t m);
#endif

39
ls/libft/Makefile Normal file
View file

@ -0,0 +1,39 @@
NAME = libft.a
CC = gcc
AR = ar -rc
D_SRC = src
D_OBJ = obj
O_FLAGS =
W_FLAGS = -Wall -Wextra -Werror
DEBUG =
MKDIR = mkdir -p
RM = /bin/rm -rf
D_INC = includes
F_SRC := $(shell find $(D_SRC) -type f -regex ".*\.c$$")
F_OBJ := $(addprefix $(D_OBJ)/, $(notdir $(F_SRC:.c=.o)))
.PHONY: all clean fclean re
all: $(NAME)
$(D_OBJ)/%.o: $(D_SRC)/*/%.c
@$(MKDIR) $(D_OBJ)
@$(CC) -I$(D_INC) $(W_FLAGS) -c $< -o $@ $(DEBUG)
@echo "(libft) Compiling "$<"..."
$(NAME): $(F_OBJ)
@$(AR) $(NAME) $(F_OBJ)
@echo "(libft) Linking "$@"..."
@ranlib $(NAME)
clean:
$(RM) $(D_OBJ)
fclean: clean
$(RM) $(NAME)
re: fclean all

56
ls/libft/includes/btree.h Normal file
View file

@ -0,0 +1,56 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* btree.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/16 11:13:15 by jhalford #+# #+# */
/* Updated: 2016/11/25 20:37:02 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef BTREE_H
# define BTREE_H
# include "libft.h"
typedef struct s_btree t_btree;
struct s_btree
{
void *item;
size_t content_size;
struct s_btree *left;
struct s_btree *right;
};
struct s_printdata
{
int is_left;
int offset;
int depth;
int left;
int right;
};
typedef struct s_printdata t_printdata;
t_btree *btree_create_node(void const *item, size_t content_size);
void btree_insert_data(
t_btree **root,
void *item,
size_t content_size,
int (*cmpf)(void *, void *));
void *btree_search_item(t_btree *root,
void *data_ref, int (*cmpf)(void *, void *));
int btree_level_count(t_btree *root);
void btree_apply_prefix(t_btree *root, void (*applyf)(void *));
void btree_apply_infix(t_btree *root, void (*applyf)(void *));
void btree_apply_suffix(t_btree *root, void (*applyf)(void *));
void btree_print(t_btree *tree, char *(*printer)(void *));
#endif

51
ls/libft/includes/color.h Normal file
View file

@ -0,0 +1,51 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* color.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/25 13:36:48 by jhalford #+# #+# */
/* Updated: 2016/11/27 13:21:19 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef COLOR_H
# define COLOR_H
# include "libft.h"
struct s_color
{
char fg[7];
char bg[7];
};
typedef struct s_color t_color;
# define FG_BLACK "\x1b[30m"
# define FG_RED "\x1b[31m"
# define FG_GREEN "\x1b[32m"
# define FG_YELLOW "\x1b[33m"
# define FG_BLUE "\x1b[34m"
# define FG_MAGENTA "\x1b[35m"
# define FG_CYAN "\x1b[36m"
# define FG_DEFAULT "\x1b[0m"
# define BG_BLACK "\x1b[40m"
# define BG_RED "\x1b[41m"
# define BG_GREEN "\x1b[42m"
# define BG_YELLOW "\x1b[43m"
# define BG_BLUE "\x1b[44m"
# define BG_MAGENTA "\x1b[45m"
# define BG_CYAN "\x1b[46m"
# define BG_DEFAULT "\x1b[49m"
# define FBG_DEFAULT "\x1b[49m\x1b[20m"
void ft_color_reset(void);
void ft_color_set(t_color color);
void ft_color_mk(t_color *color, char fg[7], char bg[7]);
void ft_color_mkif(t_color *color, int cond, char fg[7], char bg[7]);
#endif

35
ls/libft/includes/dlst.h Normal file
View file

@ -0,0 +1,35 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* dlst.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:21:04 by jhalford #+# #+# */
/* Updated: 2016/11/07 13:21:52 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef DLST_H
# define DLST_H
struct s_dlist
{
void *content;
size_t content_size;
struct s_dlist *next;
struct s_dlist *prev;
};
typedef struct s_dlist t_dlist;
void ft_dlstadd_after(t_dlist **alst, t_dlist *new);
void ft_dlstadd_before(t_dlist **alst, t_dlist *new);
void ft_dlstdel(t_dlist **alst, void (*del)(void *, size_t));
void ft_dlstdelone(t_dlist **alst, void (*del)(void *, size_t));
int ft_dlstsize(t_dlist *list);
t_dlist *ft_dlstnew(void const *content, size_t content_size);
t_dlist *ft_dlstlast(t_dlist *list);
char *ft_dlsttostr(t_dlist *list);
#endif

80
ls/libft/includes/ft_printf.h Normal file
View file

@ -0,0 +1,80 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ftprintf.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:22:54 by jhalford #+# #+# */
/* Updated: 2016/11/21 18:20:10 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef FT_PRINTF_H
# define FT_PRINTF_H
# include "libft.h"
# include <stdarg.h>
# define ALL_FLAGS "#0- +"
# define ALL_CONVERSIONS "sSpdDioOuUxXcCb"
typedef struct s_fmt t_fmt;
typedef struct s_conv t_conv;
typedef char *(t_converter)(t_fmt *fmt, va_list ap);
typedef void (t_pad_func)(char *str, t_fmt *fmt);
struct s_conv
{
char id;
char allowed_flags[6];
char base[20];
t_converter *converter;
t_pad_func *sharp_func;
};
struct s_fmt
{
char flags[6];
int width;
int precision;
char modifier[3];
char conversion;
int valid;
t_conv conv;
};
int ft_vdprintf(int fd, const char *format, va_list ap);
int ft_fmtcalc(char **final, char **str, va_list ap);
extern t_conv g_convs[];
t_fmt *ft_fmt_init(void);
void ft_fmt_print(t_fmt *fmt);
t_fmt *ft_printf_parse(char **format, va_list ap);
void ft_printf_parse_flags(t_fmt *fmt, char **format);
void ft_printf_parse_width(t_fmt *fmt, char **format, va_list ap);
void ft_printf_parse_precision(t_fmt *fmt, char **format, va_list ap);
void ft_printf_parse_modifiers(t_fmt *fmt, char **format);
char *ft_transform(t_fmt *fmt, va_list ap);
void ft_fmt_error_conv(char conv);
void ft_fmt_error_mod_conv(char *mod, char conv);
void ft_fmt_error_flag_conv(char flag, char conv);
void ft_fmt_error_flag_flag(char flag1, char flag2);
void ft_fmt_simplify(t_fmt *fmt);
int ft_fmt_validate_conv(t_fmt *fmt);
void ft_fmt_validate_flags(t_fmt *fmt);
void ft_fmt_validate_mod(t_fmt *fmt);
char *ft_signed_conversion(t_fmt *fmt, va_list ap);
char *ft_unsigned_conversion(t_fmt *fmt, va_list ap);
char *ft_str_conversion(t_fmt *fmt, va_list ap);
char *ft_char_conversion(t_fmt *fmt, va_list ap);
void ft_pad_sharp_o(char *str, t_fmt *fmt);
void ft_pad_sharp_xb(char *str, t_fmt *fmt);
void ft_pad_left(char *str, t_fmt *fmt);
void ft_pad_right(char *str, t_fmt *fmt);
#endif

21
ls/libft/includes/ft_xattr.h Normal file
View file

@ -0,0 +1,21 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ftxattr.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:24:05 by jhalford #+# #+# */
/* Updated: 2016/11/07 13:24:05 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef FT_XATTR_H
# define FT_XATTR_H
# define FT_XATTR_SIZE 10000
# include <sys/types.h>
# include <sys/xattr.h>
int ft_xattr_print(char *path);
int ft_xattr_count(char *path);
#endif

31
ls/libft/includes/get_next_line.h Normal file
View file

@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* get_next_line.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/05 12:21:36 by jhalford #+# #+# */
/* Updated: 2016/11/17 13:18:28 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef GET_NEXT_LINE_H
# define GET_NEXT_LINE_H
# define BUFF_SIZE 32
# include "libft.h"
# include <sys/types.h>
# include <sys/uio.h>
typedef struct s_save t_save;
struct s_save
{
int fd;
char *str;
};
int get_next_line(int const fd, char **line);
#endif

140
ls/libft/includes/libft.h Normal file
View file

@ -0,0 +1,140 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* libft.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:49:04 by jhalford #+# #+# */
/* Updated: 2016/11/27 13:25:46 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef LIBFT_H
# define LIBFT_H
# include "ft_xattr.h"
# include "mytime.h"
# include "lst.h"
# include "dlst.h"
# include "btree.h"
# include "color.h"
# include <string.h>
# include <unistd.h>
# include <stdio.h>
# include <stdlib.h>
# include <time.h>
# include <sys/xattr.h>
# include <sys/acl.h>
# define FT_WS(x) (x == ' ' || x == '\t' || x == '\n')
# define FT_ABS(x) (((x) < 0) ? -(x) : (x))
# define FT_NEG(x) (((x) < 0) ? 1 : 0)
# define FT_POS(x) (((x) > 0) ? 1 : 0)
# define FT_MIN(a, b) ((a) < (b) ? (a) : (b))
# define FT_MAX(a, b) ((a) > (b) ? (a) : (b))
# define FT_DIST(a, b) (FT_ABS((a) - (b)))
typedef struct s_stof t_stof;
struct s_stof
{
char *name;
int (*f)();
};
void ft_debug(void);
void *ft_memset(void *b, int c, size_t len);
void ft_bzero(void *s, size_t n);
void *ft_memcpy(void *dst, const void *src, size_t n);
void *ft_memccpy(void *dst, const void *src, int c, size_t n);
void *ft_memmove(void *dst, 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 *s1);
char *ft_strcpy(char *dst, const char *src);
char *ft_strncpy(char *dst, const char *src, size_t len);
char *ft_strcat(char *s1, const char *s2);
char *ft_strncat(char *s1, const char *s2, 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 *big, const char *little);
char *ft_strnstr(const char *big, const char *little, 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);
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);
int ft_putchar(int 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);
void ft_putaddr(void *a);
char *ft_strrev(char *str);
char **ft_strsplit(char const *s, char c);
char *ft_str3join(char const *s1, char const *s2, char const *s3);
char *ft_strcut(char *str, char *cut);
char **ft_split_whitespaces(char *str);
char *ft_convert_base(
char *str, char *base_from, char *base_to, char *flags);
char *ft_strcatf(char *s1, const char *s2);
char *ft_strinsert(char *str, char c, int n);
char *ft_itoa_base(int nbr, char *base, char *flags);
char *ft_lltoa_base(long long nbr, char *base, char *flags);
char *ft_ulltoa_base(unsigned long long nbr, char *base);
char *ft_uitoa_base(unsigned int nbr, char *base);
size_t ft_ilen(int n);
size_t ft_ilen_base(int n, int base);
size_t ft_uilen(unsigned int n);
size_t ft_lllen(long long n);
size_t ft_lllen_base(long long n, int base);
int ft_addrcmp(void *a, void *b);
char **ft_sstradd(char **list, char *new);
void ft_sstrsort(char **list, int (*cmp)());
void ft_sstrprint(char **list, char sep);
char **ft_sstrdup(char **list);
void ft_sstrdel(char **sstr, int index);
void ft_sstrfree(char **sstr);
char *ft_path_notdir(char *path);
int ft_printf(const char *format, ...);
int ft_dprintf(int fd, const char *format, ...);
char *ft_getenv(char **env, char *key);
void *ft_realloc(void *data, int size);
#endif

76
ls/libft/includes/lst.h Normal file
View file

@ -0,0 +1,76 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lst.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:27:46 by jhalford #+# #+# */
/* Updated: 2016/11/23 14:50:54 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef LST_H
# define LST_H
struct s_list
{
void *content;
size_t content_size;
struct s_list *next;
};
typedef struct s_list t_list;
t_list *ft_lstnew(void const *content, size_t content_size);
void ft_lstdel(t_list **alst, void (*del)(void *, size_t));
void ft_lstdelone(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));
t_list *ft_lstnew_range(int a, int b);
void ft_lsteadd(t_list **alst, t_list *new);
void ft_lstnadd(t_list **alst, t_list *new, int n);
void ft_lstsort(t_list **begin_list, int (*cmp)());
void ft_lst_print(t_list *list, void (*printer)());
int ft_lstsize(t_list *lst);
t_list *ft_lstlast(t_list *lst);
void ft_lst_sorted_merge(
t_list **begin_list1,
t_list *begin_list2,
int (*cmp)());
void ft_lst_sorted_insert(
t_list **begin_list,
t_list *insert,
int (*cmp)());
void ft_lst_delif(
t_list **alist,
void *data_ref,
int (*cmp)(),
void (*del)(void *, size_t));
void ft_lst_delsub(
t_list **alst,
t_list *sub, int (*cmp)(),
void (*del)(void *, size_t));
void ft_lst_cfree(void *ptr, size_t size);
t_list *ft_lst_filter(
t_list *lst,
void const *data_ref,
t_list *(*f)(t_list *elem, void const *));
t_list *ft_lst_removeif(
t_list **alst,
void *data_ref,
int (*cmp)());
t_list *ft_lst_find(
t_list *begin_list,
void *data_ref,
int (*cmp)());
t_list *ft_lstpop(t_list **lst);
void ft_lst_merge(t_list **begin_list1, t_list *begin_list2);
void ft_lst_reverse(t_list **begin_list);
int ft_diff(void *a, void *b);
t_list *ft_id(t_list *a);
#endif

34
ls/libft/includes/mytime.h Normal file
View file

@ -0,0 +1,34 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* mytime.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/25 11:43:12 by jhalford #+# #+# */
/* Updated: 2016/11/25 20:26:20 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef MYTIME_H
# define MYTIME_H
# include "libft.h"
struct s_mytime
{
char *year;
char *month;
char *day;
char *hour;
char *min;
char *sec;
};
typedef struct s_mytime t_mytime;
int ft_time_isrecent(time_t event);
t_mytime *ft_mytime_get(time_t epoch);
void ft_mytime_free(t_mytime **time);
#endif

BIN
ls/libft/pdf/ft_printf.pdf Normal file
View file

Binary file not shown.

BIN
ls/libft/pdf/get_next_line.fr.pdf Normal file
View file

Binary file not shown.

BIN
ls/libft/pdf/libft.fr.pdf Normal file
View file

Binary file not shown.

46
ls/libft/src/btree/btree_apply_by_level.c Normal file
View file

@ -0,0 +1,46 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* btree_apply_by_level.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/08/19 12:06:15 by jhalford #+# #+# */
/* Updated: 2016/11/16 11:14:28 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "btree.h"
int g_level = 0;
static void btree_apply_to_level(
t_btree *root,
int level,
int is_first_elem,
void (*applyf)(void *item, int current_level, int is_first_elem))
{
if (level == g_level)
{
(*applyf)(root->item, level, is_first_elem);
return ;
}
if (root->left)
btree_apply_to_level(root->left, level + 1, is_first_elem, applyf);
if (root->right)
btree_apply_to_level(root->right, level + 1, 0, applyf);
}
void btree_apply_by_level(
t_btree *root,
void (*applyf)(void *item, int current_level, int is_first_elem))
{
int height;
height = btree_level_count(root);
while (g_level < height)
{
btree_apply_to_level(root, 0, 1, applyf);
g_level++;
}
}

23
ls/libft/src/btree/btree_apply_infix.c Normal file
View file

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* btree_create_node.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/08/16 13:43:51 by jhalford #+# #+# */
/* Updated: 2016/11/14 11:58:47 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "btree.h"
void btree_apply_infix(t_btree *root, void (*applyf)(void *))
{
if (root->left)
btree_apply_infix(root->left, applyf);
(*applyf)(root->item);
if (root->right)
btree_apply_infix(root->right, applyf);
return ;
}

22
ls/libft/src/btree/btree_apply_prefix.c Normal file
View file

@ -0,0 +1,22 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* btree_create_node.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/08/16 13:43:51 by jhalford #+# #+# */
/* Updated: 2016/08/18 21:06:44 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "btree.h"
void btree_apply_prefix(t_btree *root, void (*applyf)(void *))
{
(*applyf)(root->item);
if (root->left)
btree_apply_prefix(root->left, applyf);
if (root->right)
btree_apply_prefix(root->right, applyf);
}

23
ls/libft/src/btree/btree_apply_suffix.c Normal file
View file

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* btree_create_node.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/08/16 13:43:51 by jhalford #+# #+# */
/* Updated: 2016/11/14 16:08:23 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "btree.h"
void btree_apply_suffix(t_btree *root, void (*applyf)(void *))
{
if (root->left)
btree_apply_suffix(root->left, applyf);
if (root->right)
btree_apply_suffix(root->right, applyf);
(*applyf)(root->item);
return ;
}

35
ls/libft/src/btree/btree_create_node.c Normal file
View file

@ -0,0 +1,35 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* btree_create_node.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/08/16 13:43:51 by jhalford #+# #+# */
/* Updated: 2016/11/14 16:11:49 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "btree.h"
t_btree *btree_create_node(void const *item, size_t content_size)
{
t_btree *new;
if (!(new = (t_btree *)malloc(sizeof(t_btree))))
return (NULL);
new->left = 0;
new->right = 0;
if (!item)
{
new->content_size = 0;
new->item = NULL;
}
else
{
new->content_size = content_size;
new->item = ft_memalloc(content_size + 1);
ft_memcpy(new->item, item, content_size);
}
return (new);
}

43
ls/libft/src/btree/btree_insert_data.c Normal file
View file

@ -0,0 +1,43 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* btree_create_node.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/08/16 13:43:51 by jhalford #+# #+# */
/* Updated: 2016/11/14 16:12:47 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "btree.h"
void btree_insert_data(
t_btree **root,
void *item,
size_t content_size,
int (*cmpf)(void *, void *))
{
t_btree *node;
if (!*root)
{
*root = btree_create_node(item, content_size);
return ;
}
node = *root;
if ((*cmpf)(item, node->item) < 0)
{
if (node->left)
btree_insert_data(&node->left, item, content_size, cmpf);
else
node->left = btree_create_node(item, content_size);
}
else
{
if (node->right)
btree_insert_data(&node->right, item, content_size, cmpf);
else
node->right = btree_create_node(item, content_size);
}
}

21
ls/libft/src/btree/btree_level_count.c Normal file
View file

@ -0,0 +1,21 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* btree_create_node.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/08/16 13:43:51 by jhalford #+# #+# */
/* Updated: 2016/08/25 17:46:00 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "btree.h"
int btree_level_count(t_btree *root)
{
return (root
? 1 + FT_MAX(btree_level_count(root->left),
btree_level_count(root->right))
: 0);
}

80
ls/libft/src/btree/btree_print.c Normal file
View file

@ -0,0 +1,80 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* btree_print.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/14 18:06:24 by jhalford #+# #+# */
/* Updated: 2016/11/25 20:44:56 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "btree.h"
static int print_t2(t_printdata data, char s[20][255], char b[20])
{
int width;
int i;
width = 5;
i = -1;
while (++i < width)
s[2 * data.depth][data.offset + data.left + i] = b[i];
i = -1;
if (data.depth && data.is_left)
{
while (++i < width + data.right)
s[2 * data.depth - 1]
[data.offset + data.left + width / 2 + i] = '-';
s[2 * data.depth - 1][data.offset + data.left + width / 2] = '+';
s[2 * data.depth - 1]
[data.offset + data.left + data.right + 3 * width / 2] = '+';
}
else if (data.depth && !data.is_left)
{
while (++i < width + data.left)
s[2 * data.depth - 1][data.offset - width / 2 + i] = '-';
s[2 * data.depth - 1][data.offset + data.left + width / 2] = '+';
s[2 * data.depth - 1][data.offset - width / 2 - 1] = '+';
}
return (data.left + width + data.right);
}
static int print_t(t_btree *tree,
t_printdata data, char s[20][255], char *(*printer)(void *))
{
char b[20];
int width;
width = 5;
if (!tree)
return (0);
sprintf(b, "%5s", printer(tree->item));
data.left = print_t(tree->left, (t_printdata){
1, data.offset, data.depth + 1, data.left, data.right}, s, printer);
data.right = print_t(tree->right, (t_printdata){
0, data.offset + data.left + width, data.depth + 1,
data.left, data.right}, s, printer);
return (print_t2(data, s, b));
}
void btree_print(t_btree *tree, char *(*printer)(void *))
{
char s[20][255];
char empty[255];
int i;
i = -1;
while (++i < 20)
sprintf(s[i], "%80s", " ");
sprintf(empty, "%80s", " ");
print_t(tree, (t_printdata){0, 0, 0, 0, 0}, s, printer);
i = -1;
while (++i < 20)
{
if (ft_strcmp(s[i], empty) == 0)
break ;
printf("%s\n", s[i]);
}
}

30
ls/libft/src/btree/btree_search_item.c Normal file
View file

@ -0,0 +1,30 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* btree_create_node.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/08/16 13:43:51 by jhalford #+# #+# */
/* Updated: 2016/08/23 19:04:56 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "btree.h"
void *btree_search_item(t_btree *root,
void *data_ref, int (*cmpf)(void *, void *))
{
void *out;
out = NULL;
if (root)
{
out = btree_search_item(root->left, data_ref, cmpf);
if (!out && ((*cmpf)(root->item, data_ref) == 0))
out = root->item;
if (!out)
out = btree_search_item(root->right, data_ref, cmpf);
}
return (out);
}

22
ls/libft/src/char/ft_isalnum.c Normal file
View file

@ -0,0 +1,22 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isalnum.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/03 14:56:18 by jhalford #+# #+# */
/* Updated: 2016/11/03 15:31:33 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_isalnum(int c)
{
if ((c >= 'a' && c <= 'z')
|| (c >= 'A' && c <= 'Z')
|| (c >= '0' && c <= '9'))
return (c);
return (0);
}

20
ls/libft/src/char/ft_isalpha.c Normal file
View file

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isalpha.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/03 14:56:24 by jhalford #+# #+# */
/* Updated: 2016/11/03 15:32:00 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_isalpha(int c)
{
if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
return (c);
return (0);
}

20
ls/libft/src/char/ft_isascii.c Normal file
View file

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isascii.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/03 14:56:28 by jhalford #+# #+# */
/* Updated: 2016/11/03 15:35:42 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_isascii(int c)
{
if (c >= 0 && c <= 127)
return (1);
return (0);
}

23
ls/libft/src/char/ft_isdigit.c Normal file
View file

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isdigit.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/03 14:56:33 by jhalford #+# #+# */
/* Updated: 2016/11/03 14:56:34 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_isdigit(int c)
{
unsigned char a;
a = (unsigned char)c;
if (a >= '0' && a <= '9')
return (a);
return (0);
}

20
ls/libft/src/char/ft_isprint.c Normal file
View file

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isprint.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/03 14:56:38 by jhalford #+# #+# */
/* Updated: 2016/11/03 15:32:40 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_isprint(int c)
{
if (c >= 32 && c <= 126)
return (c);
return (0);
}

20
ls/libft/src/char/ft_tolower.c Normal file
View file

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_tolower.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/03 14:58:46 by jhalford #+# #+# */
/* Updated: 2016/11/03 15:24:09 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_tolower(int c)
{
if (c >= 'A' && c <= 'Z')
return (c + 32);
return (c);
}

20
ls/libft/src/char/ft_toupper.c Normal file
View file

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_toupper.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/03 14:53:58 by jhalford #+# #+# */
/* Updated: 2016/11/03 15:24:40 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_toupper(int c)
{
if (c >= 'a' && c <= 'z')
return (c - 32);
return (c);
}

19
ls/libft/src/color/ft_color_mk.c Normal file
View file

@ -0,0 +1,19 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_color_mk.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/27 11:35:18 by jhalford #+# #+# */
/* Updated: 2016/11/27 11:36:07 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_color_mk(t_color *color, char fg[7], char bg[7])
{
ft_strcpy(color->fg, fg);
ft_strcpy(color->bg, bg);
}

19
ls/libft/src/color/ft_color_mkif.c Normal file
View file

@ -0,0 +1,19 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_color_mk.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/27 11:35:18 by jhalford #+# #+# */
/* Updated: 2016/11/27 11:36:52 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_color_mkif(t_color *color, int cond, char fg[7], char bg[7])
{
if (cond)
ft_color_mk(color, fg, bg);
}

19
ls/libft/src/color/ft_color_reset.c Normal file
View file

@ -0,0 +1,19 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_color_reset.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/25 13:48:05 by jhalford #+# #+# */
/* Updated: 2016/11/27 11:42:24 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_color_reset(void)
{
ft_putstr(FG_DEFAULT);
ft_putstr(BG_DEFAULT);
}

22
ls/libft/src/color/ft_color_set.c Normal file
View file

@ -0,0 +1,22 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_color_set.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/25 13:53:46 by jhalford #+# #+# */
/* Updated: 2016/11/27 11:29:16 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_color_set(t_color color)
{
char out[20];
ft_strcpy(out, color.fg);
ft_strcat(out, color.bg);
ft_putstr(out);
}

30
ls/libft/src/dlst/ft_dlstadd_after.c Normal file
View file

@ -0,0 +1,30 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_dlst_add_after.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:27:04 by jhalford #+# #+# */
/* Updated: 2016/11/07 13:27:36 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_dlstadd_after(t_dlist **alst, t_dlist *new)
{
if (new)
{
new->prev = (*alst);
if (*alst)
new->next = (*alst)->next;
else
new->next = NULL;
if (new->next)
new->next->prev = new;
if (new->prev)
new->prev->next = new;
*alst = new;
}
}

28
ls/libft/src/dlst/ft_dlstadd_before.c Normal file
View file

@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_dlst_add_before.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:27:09 by jhalford #+# #+# */
/* Updated: 2016/11/07 13:27:10 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_dlstadd_before(t_dlist **alst, t_dlist *new)
{
if (new)
{
new->next = (*alst);
if (*alst)
new->prev = (*alst)->prev;
if (new->next)
new->next->prev = new;
if (new->prev)
new->prev->next = new;
*alst = new;
}
}

41
ls/libft/src/dlst/ft_dlstdel.c Normal file
View file

@ -0,0 +1,41 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_dlstdel.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/14 17:55:40 by jhalford #+# #+# */
/* Updated: 2016/11/16 11:15:40 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
static void ft_dlstdelback(t_dlist **alst, void (*del)(void *, size_t))
{
if (alst && *alst && del)
{
ft_dlstdelback(&(*alst)->prev, del);
ft_dlstdelone(alst, del);
}
}
static void ft_dlstdelfront(t_dlist **alst, void (*del)(void *, size_t))
{
if (alst && *alst && del)
{
ft_dlstdelfront(&(*alst)->next, del);
ft_dlstdelone(alst, del);
}
}
void ft_dlstdel(t_dlist **alst, void (*del)(void *, size_t))
{
if (alst && *alst && del)
{
ft_dlstdelback(&(*alst)->prev, del);
ft_dlstdelfront(&(*alst)->next, del);
ft_dlstdelone(alst, del);
}
}

34
ls/libft/src/dlst/ft_dlstdelone.c Normal file
View file

@ -0,0 +1,34 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_dlst_delone.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:27:13 by jhalford #+# #+# */
/* Updated: 2016/11/14 17:52:58 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_dlstdelone(t_dlist **alst, void (*del)(void *, size_t))
{
t_dlist *tmp;
tmp = *alst;
if (tmp)
{
if (del)
(*del)(tmp->content, tmp->content_size);
if (tmp->next)
tmp->next->prev = tmp->prev;
if (tmp->prev)
tmp->prev->next = tmp->next;
if (tmp->prev)
*alst = tmp->prev;
else
*alst = tmp->next;
free(tmp);
}
}

20
ls/libft/src/dlst/ft_dlstlast.c Normal file
View file

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_dlst_last.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:27:15 by jhalford #+# #+# */
/* Updated: 2016/11/07 13:27:15 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_dlist *ft_dlstlast(t_dlist *list)
{
while (list && list->next)
list = list->next;
return (list);
}

39
ls/libft/src/dlst/ft_dlstnew.c Normal file
View file

@ -0,0 +1,39 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_dlst_new.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:27:20 by jhalford #+# #+# */
/* Updated: 2016/11/07 13:27:20 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_dlist *ft_dlstnew(void const *content, size_t content_size)
{
t_dlist *new;
if (!content)
{
new = malloc(sizeof(*new));
if (!new)
return (NULL);
new->content_size = 0;
new->content = NULL;
}
else
{
new = (t_dlist *)malloc(sizeof(*new));
if (!new)
return (NULL);
new->content_size = content_size;
new->content = ft_memalloc(content_size + 1);
ft_memcpy(new->content, content, content_size);
}
new->next = NULL;
new->prev = NULL;
return (new);
}

30
ls/libft/src/dlst/ft_dlstrtostr.c Normal file
View file

@ -0,0 +1,30 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_dlstrtostr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:27:29 by jhalford #+# #+# */
/* Updated: 2016/11/14 16:13:24 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_dlsttostr(t_dlist *list)
{
char *str;
if (!list)
return (NULL);
while (list->prev)
list = list->prev;
str = (char *)ft_strnew(sizeof(char) * (ft_dlstsize(list) + 2));
while (list)
{
ft_strcat(str, (char *)list->content);
list = list->next;
}
return (str);
}

36
ls/libft/src/dlst/ft_dlstsize.c Normal file
View file

@ -0,0 +1,36 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_dlst_size.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:27:23 by jhalford #+# #+# */
/* Updated: 2016/11/07 13:27:23 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_dlstsize(t_dlist *list)
{
int size;
t_dlist *tmp;
size = 0;
if (list)
size++;
tmp = list;
while (tmp->next)
{
size++;
tmp = tmp->next;
}
tmp = list;
while (tmp->prev)
{
size++;
tmp = tmp->prev;
}
return (size);
}

26
ls/libft/src/env/ft_getenv.c vendored Normal file
View file

@ -0,0 +1,26 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_getenv.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/10 14:30:00 by jhalford #+# #+# */
/* Updated: 2016/11/16 11:24:52 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
char *ft_getenv(char **env, char *key)
{
if (!env)
return (NULL);
while (*env)
{
if (ft_strcmp(*env, key) == '=')
return (*env + ft_strlen(key) + 1);
env++;
}
return (NULL);
}

67
ls/libft/src/ft_printf/ft_conversion.c Normal file
View file

@ -0,0 +1,67 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_conversion.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:31:48 by jhalford #+# #+# */
/* Updated: 2016/11/16 18:30:20 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "ft_printf.h"
char *ft_signed_conversion(t_fmt *fmt, va_list ap)
{
char base10[11];
long long arg;
arg = va_arg(ap, int);
ft_strcpy(base10, "0123456789");
(void)fmt;
return (ft_lltoa_base(arg, base10, fmt->flags));
}
char *ft_unsigned_conversion(t_fmt *fmt, va_list ap)
{
unsigned int uiarg;
unsigned long long ullarg;
int i;
i = 0;
while (fmt->conversion != g_convs[i].id)
i++;
if (!*fmt->modifier
|| ft_strequ(fmt->modifier, "hh")
|| ft_strequ(fmt->modifier, "h")
|| ft_strequ(fmt->modifier, "z"))
{
uiarg = va_arg(ap, int);
return (ft_uitoa_base(uiarg, g_convs[i].base));
}
ullarg = va_arg(ap, long long);
return (ft_ulltoa_base(ullarg, g_convs[i].base));
}
char *ft_char_conversion(t_fmt *fmt, va_list ap)
{
char *ret;
(void)fmt;
ret = (char *)malloc(sizeof(char) + 1);
ret[0] = (char)va_arg(ap, int);
ret[1] = '\0';
return (ret);
}
char *ft_str_conversion(t_fmt *fmt, va_list ap)
{
char *ret;
(void)fmt;
ret = ft_strdup(va_arg(ap, char *));
if (fmt->precision && fmt->precision < (int)ft_strlen(ret))
ret[fmt->precision] = '\0';
return (ret);
}

31
ls/libft/src/ft_printf/ft_fmt_simplify.c Normal file
View file

@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lib_fmt_validate.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:33:43 by jhalford #+# #+# */
/* Updated: 2016/11/07 16:53:54 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "ft_printf.h"
void ft_fmt_simplify(t_fmt *fmt)
{
char hashtag;
hashtag = '#';
if (fmt->conversion == 'p')
{
fmt->conversion = 'x';
if (!ft_strchr(fmt->flags, '#'))
ft_strncat(fmt->flags, &hashtag, 1);
}
if (ft_strchr("DOUCS", fmt->conversion))
{
fmt->conversion += 32;
ft_strcpy(fmt->modifier, "l");
}
}

24
ls/libft/src/ft_printf/ft_fmt_validate_conv.c Normal file
View file

@ -0,0 +1,24 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_fmt_validate_conv.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 16:55:36 by jhalford #+# #+# */
/* Updated: 2016/11/07 16:55:37 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "ft_printf.h"
int ft_fmt_validate_conv(t_fmt *fmt)
{
if (!ft_strchr(ALL_CONVERSIONS, fmt->conversion))
{
if (fmt->conversion != '%')
ft_fmt_error_conv(fmt->conversion);
return (1);
}
return (0);
}

63
ls/libft/src/ft_printf/ft_fmt_validate_flags.c Normal file
View file

@ -0,0 +1,63 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_fmt_validate_flags.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 16:53:07 by jhalford #+# #+# */
/* Updated: 2016/11/16 11:15:55 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "ft_printf.h"
static void ft_fmt_validate_flag_flag(t_fmt *fmt)
{
char *flag_ptr;
if (ft_strchr(fmt->flags, '+') && (flag_ptr = ft_strchr(fmt->flags, ' ')))
{
ft_fmt_error_flag_flag(' ', '+');
*flag_ptr = '.';
}
if (ft_strchr(fmt->flags, '-') && (flag_ptr = ft_strchr(fmt->flags, '0')))
{
ft_fmt_error_flag_flag('0', '-');
*flag_ptr = '.';
}
if (fmt->precision && (flag_ptr = ft_strchr(fmt->flags, '0')))
*flag_ptr = '.';
}
static void ft_fmt_validate_flag_conv(t_fmt *fmt)
{
char *flag_ptr;
char flag;
int i;
i = 0;
flag_ptr = fmt->flags;
while (fmt->conversion != g_convs[i].id)
i++;
while (*flag_ptr)
{
flag = *flag_ptr;
if (!ft_strchr(g_convs[i].allowed_flags, flag))
{
ft_fmt_error_flag_conv(flag, fmt->conversion);
if (flag == '#')
*flag_ptr = '.';
}
flag_ptr++;
}
}
void ft_fmt_validate_flags(t_fmt *fmt)
{
int i;
i = 0;
ft_fmt_validate_flag_conv(fmt);
ft_fmt_validate_flag_flag(fmt);
}

20
ls/libft/src/ft_printf/ft_fmt_validate_mod.c Normal file
View file

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_fmt_validate_conv.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 16:53:42 by jhalford #+# #+# */
/* Updated: 2016/11/07 16:53:52 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "ft_printf.h"
void ft_fmt_validate_mod(t_fmt *fmt)
{
if (fmt->conversion == 's' || fmt->conversion == 'c')
if (fmt->modifier[0] && ft_strcmp(fmt->modifier, "l"))
ft_fmt_error_mod_conv(fmt->modifier, fmt->conversion);
}

87
ls/libft/src/ft_printf/ft_printf.c Normal file
View file

@ -0,0 +1,87 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_printf.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:33:27 by jhalford #+# #+# */
/* Updated: 2016/11/21 18:22:26 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "ft_printf.h"
t_conv g_convs[] =
{
{'d', "0- +", "0123456789", &ft_signed_conversion, NULL},
{'i', "0- +", "0123456789", &ft_signed_conversion, NULL},
{'u', "0-", "0123456789", &ft_unsigned_conversion, NULL},
{'o', "#0-", "01234567", &ft_unsigned_conversion, &ft_pad_sharp_o},
{'x', "#0-", "0123456789abcdef", &ft_unsigned_conversion, &ft_pad_sharp_xb},
{'X', "#0-", "0123456789ABCDEF", &ft_unsigned_conversion, &ft_pad_sharp_xb},
{'b', "#0-", "01", &ft_unsigned_conversion, &ft_pad_sharp_xb},
{'s', "-", "", &ft_str_conversion, NULL},
{'c', "-", "", &ft_char_conversion, NULL},
};
int ft_printf(const char *format, ...)
{
va_list ap;
va_start(ap, format);
return (ft_vdprintf(1, format, ap));
}
int ft_dprintf(int fd, const char *format, ...)
{
va_list ap;
va_start(ap, format);
return (ft_vdprintf(fd, format, ap));
}
int ft_vdprintf(int fd, const char *format, va_list ap)
{
char *str;
char *tmp;
char *final;
str = (char *)format;
final = ft_strnew(1);
while (*str)
{
tmp = final;
if (*str == '%')
{
if (ft_fmtcalc(&final, &str, ap))
return (1);
}
else
final = ft_strjoin(final, (char[]){*str++, 0});
ft_strdel(&tmp);
}
ft_putstr_fd(final, fd);
ft_strdel(&final);
return (0);
}
int ft_fmtcalc(char **final, char **str, va_list ap)
{
t_fmt *fmt;
char *transform;
*str += 1;
if (!(fmt = ft_printf_parse(str, ap)))
return (1);
if (!fmt->valid)
ft_strncat(*final, &fmt->conversion, 1);
else
{
transform = ft_transform(fmt, ap);
*final = ft_strjoin(*final, transform);
ft_strdel(&transform);
}
free(fmt);
return (0);
}

123
ls/libft/src/ft_printf/ft_printf_parse.c Normal file
View file

@ -0,0 +1,123 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_parse.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:33:24 by jhalford #+# #+# */
/* Updated: 2016/11/10 12:59:50 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "ft_printf.h"
t_fmt *ft_printf_parse(char **format, va_list ap)
{
t_fmt *fmt;
fmt = ft_fmt_init();
ft_printf_parse_flags(fmt, format);
ft_printf_parse_width(fmt, format, ap);
ft_printf_parse_precision(fmt, format, ap);
ft_printf_parse_modifiers(fmt, format);
fmt->conversion = **format;
(*format)++;
ft_fmt_validate_mod(fmt);
ft_fmt_validate_flags(fmt);
ft_fmt_simplify(fmt);
fmt->valid = ft_fmt_validate_conv(fmt) ? 0 : 1;
return (fmt);
}
void ft_printf_parse_flags(t_fmt *fmt, char **format)
{
int i;
char *str;
i = 0;
str = *format;
while (str[i])
{
if (ft_strchr(ALL_FLAGS, (int)str[i]))
{
if (!ft_strchr(fmt->flags, (int)str[i]))
ft_strncat(fmt->flags, str + i, 1);
}
else
break ;
i++;
}
*format += i;
}
void ft_printf_parse_width(t_fmt *fmt, char **format, va_list ap)
{
int i;
char buf[10];
char *str;
i = 0;
str = *format;
if (str[i] == '*')
{
i++;
fmt->width = va_arg(ap, int);
}
else
{
ft_strcpy(buf, "0");
while (ft_isdigit((int)(str[i])))
ft_strncat(buf, str + i++, 1);
fmt->width = ft_atoi(buf);
}
*format += i;
}
void ft_printf_parse_precision(t_fmt *fmt, char **format, va_list ap)
{
int i;
char buf[10];
char *str;
i = 0;
str = *format;
if (str[i] == '.')
{
if (str[++i] == '*')
{
i++;
fmt->precision = va_arg(ap, int);
}
else
{
ft_strcpy(buf, "0");
while (ft_isdigit(str[i]))
ft_strncat(buf, str + i++, 1);
fmt->precision = ft_atoi(buf);
}
}
*format += i;
}
void ft_printf_parse_modifiers(t_fmt *fmt, char **format)
{
char *str;
str = *format;
if (str[0] == 'h' && str[1] == 'h')
ft_strcpy(fmt->modifier, "hh");
else if (str[0] == 'h' && str[1] != 'h')
ft_strcpy(fmt->modifier, "h");
else if (str[0] == 'l' && str[1] == 'l')
ft_strcpy(fmt->modifier, "ll");
else if (str[0] == 'l' && str[1] != 'l')
ft_strcpy(fmt->modifier, "l");
else if (str[0] == 'j')
ft_strcpy(fmt->modifier, "j");
else if (str[0] == 'z')
ft_strcpy(fmt->modifier, "z");
else
ft_strcpy(fmt->modifier, "");
*format += ft_strlen(fmt->modifier);
}

32
ls/libft/src/ft_printf/ft_transform.c Normal file
View file

@ -0,0 +1,32 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_transform.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:33:32 by jhalford #+# #+# */
/* Updated: 2016/11/16 17:56:37 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "ft_printf.h"
char *ft_transform(t_fmt *fmt, va_list ap)
{
char *ret;
int i;
i = 0;
while (fmt->conversion != g_convs[i].id)
i++;
fmt->conv = g_convs[i];
ret = (*fmt->conv.converter)(fmt, ap);
if (fmt->width > (int)ft_strlen(ret))
ret = ft_realloc(ret, fmt->width + 5);
if (ft_strchr(fmt->flags, '-'))
ft_pad_right(ret, fmt);
else
ft_pad_left(ret, fmt);
return (ret);
}

49
ls/libft/src/ft_printf/lib_fmt.c Normal file
View file

@ -0,0 +1,49 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lib_fmt.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:33:35 by jhalford #+# #+# */
/* Updated: 2016/11/16 17:46:16 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "ft_printf.h"
t_fmt *ft_fmt_init(void)
{
t_fmt *fmt;
fmt = (t_fmt *)malloc(sizeof(t_fmt) + 1);
ft_bzero(fmt->flags, 6);
ft_bzero(fmt->modifier, 3);
fmt->conversion = '\0';
fmt->width = 0;
fmt->precision = 0;
fmt->valid = 0;
return (fmt);
}
void ft_fmt_print(t_fmt *fmt)
{
ft_putendl("\n---");
ft_putstr("valid: ");
ft_putnbr(fmt->valid);
ft_putendl("");
ft_putstr("conv.: ");
ft_putchar(fmt->conversion);
ft_putendl("");
ft_putstr("flags: ");
ft_putendl(fmt->flags);
ft_putstr("width: ");
ft_putnbr(fmt->width);
ft_putendl("");
ft_putstr("prec.: ");
ft_putnbr(fmt->precision);
ft_putendl("");
ft_putstr("modifier: ");
ft_putendl(fmt->modifier);
ft_putendl("---");
}

47
ls/libft/src/ft_printf/lib_fmt_error.c Normal file
View file

@ -0,0 +1,47 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lib_fmt_error.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:33:38 by jhalford #+# #+# */
/* Updated: 2016/11/07 17:22:41 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "ft_printf.h"
void ft_fmt_error_conv(char conv)
{
ft_putstr("Warning: invalid or unsupported conversion specifier '");
ft_putchar(conv);
ft_putendl("'");
}
void ft_fmt_error_mod_conv(char *mod, char conv)
{
ft_putstr("warning: length modifier '");
ft_putstr(mod);
ft_putstr("' results in undefined behaviour or no effect with '");
ft_putchar(conv);
ft_putendl("' conversion specifier");
}
void ft_fmt_error_flag_conv(char flag, char conv)
{
ft_putstr("warning: flag '");
ft_putchar(flag);
ft_putstr("' results in undefined behaviour with '");
ft_putchar(conv);
ft_putendl("' conversion specifier");
}
void ft_fmt_error_flag_flag(char flag1, char flag2)
{
ft_putstr("warning: flag '");
ft_putchar(flag1);
ft_putstr("' is ignored when flag '");
ft_putchar(flag2);
ft_putendl("' is present");
}

42
ls/libft/src/ft_printf/lib_pad.c Normal file
View file

@ -0,0 +1,42 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lib_pad.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:33:45 by jhalford #+# #+# */
/* Updated: 2016/11/16 18:13:08 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "ft_printf.h"
void ft_pad_right(char *str, t_fmt *fmt)
{
if (ft_strchr(fmt->flags, '#'))
(fmt->conv.sharp_func)(str, fmt);
while ((int)ft_strlen(str) < fmt->width)
ft_strcat(str, " ");
}
void ft_pad_left(char *str, t_fmt *fmt)
{
char sign;
sign = 0;
if (str[0] == '-' || str[0] == '+' || str[0] == ' ')
{
sign = str[0];
str++;
}
if (ft_strchr(fmt->flags, '0'))
while ((int)ft_strlen(str) < fmt->width - (sign ? 1 : 0))
ft_strcatf(str, "0");
if (sign)
str--;
if (ft_strchr(fmt->flags, '#'))
(fmt->conv.sharp_func)(str, fmt);
while ((int)ft_strlen(str) < fmt->width)
ft_strcatf(str, " ");
}

40
ls/libft/src/ft_printf/lib_pad_sharp.c Normal file
View file

@ -0,0 +1,40 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lib_pad_sharp.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:33:48 by jhalford #+# #+# */
/* Updated: 2016/11/16 17:56:42 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "ft_printf.h"
void ft_pad_sharp_o(char *str, t_fmt *fmt)
{
char buf[100];
(void)fmt;
ft_bzero(buf, 100);
if (str[0] != '0')
ft_strcatf(buf, "0");
}
void ft_pad_sharp_xb(char *str, t_fmt *fmt)
{
char buf[100];
int i;
i = 0;
ft_bzero(buf, 100);
ft_strcpy(buf, "0");
ft_strcat(buf, &fmt->conversion);
if (*str == '0')
i++;
if (*str == '0')
i++;
ft_strcat(buf, str + i);
ft_strcpy(str, buf);
}

79
ls/libft/src/get_next_line/get_next_line.c Normal file
View file

@ -0,0 +1,79 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* get_next_line.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/15 13:12:06 by jhalford #+# #+# */
/* Updated: 2016/11/17 13:12:08 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "get_next_line.h"
static int ft_fdcmp(t_save *a, int *b)
{
return (a->fd - *b);
}
static t_list *ft_newfd(t_list **head, int fd)
{
t_save new;
new.fd = fd;
new.str = ft_memalloc((BUFF_SIZE > 0 ? BUFF_SIZE : 0) + 1);
ft_lstadd(head, ft_lstnew(&new, sizeof(t_save)));
return (*head);
}
static int ft_loop_read(int fd, char **line, char *save)
{
char buf[BUFF_SIZE + 1];
char *pos;
char *tmp;
int ret;
while ((ret = read(fd, buf, BUFF_SIZE)) > 0)
{
buf[ret] = 0;
tmp = *line;
if ((pos = ft_strchr(buf, '\n')))
{
ft_strcpy(save, pos + 1);
*pos = 0;
}
if (!(*line = ft_strjoin(*line, buf)))
return (-1);
ft_strdel(&tmp);
if (pos)
return (1);
}
if (ret < 0)
return (-1);
return (**line ? 1 : 0);
}
int get_next_line(int const fd, char **line)
{
static t_list *head;
t_list *tmp;
char *pos;
char *save;
if (fd < 0 || !line)
return (-1);
if (!(tmp = ft_lst_find(head, (void *)&fd, &ft_fdcmp)))
tmp = ft_newfd(&head, fd);
save = ((t_save*)tmp->content)->str;
if (!(*line = ft_strdup(save)))
return (-1);
ft_bzero(save, BUFF_SIZE + 1);
if ((pos = ft_strchr(*line, '\n')))
{
ft_strcpy(save, pos + 1);
*pos = 0;
return (1);
}
return (ft_loop_read(fd, line, save));
}

18
ls/libft/src/lst/ft_id.c Normal file
View file

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_id.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/04 11:08:55 by jhalford #+# #+# */
/* Updated: 2016/11/04 11:10:25 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_list *ft_id(t_list *a)
{
return (a);
}

20
ls/libft/src/lst/ft_lst_cfree.c Normal file
View file

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lst_cfree.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/04 11:09:10 by jhalford #+# #+# */
/* Updated: 2016/11/08 11:09:49 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lst_cfree(void *ptr, size_t size)
{
(void)size;
if (ptr)
free(ptr);
}

36
ls/libft/src/lst/ft_lst_delif.c Normal file
View file

@ -0,0 +1,36 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lst_delif.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/04 11:09:12 by jhalford #+# #+# */
/* Updated: 2016/11/21 14:22:51 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lst_delif(
t_list **alst,
void *data_ref,
int (*cmp)(),
void (*del)(void *, size_t))
{
t_list *tmp;
t_list **indirect;
indirect = alst;
while (*indirect)
{
if ((*cmp)((*indirect)->content, data_ref) == 0)
{
tmp = (*indirect);
(*indirect) = (*indirect)->next;
ft_lstdelone(&tmp, del);
}
else
indirect = &(*indirect)->next;
}
}

36
ls/libft/src/lst/ft_lst_delsub.c Normal file
View file

@ -0,0 +1,36 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lst_delsub.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/04 11:09:15 by jhalford #+# #+# */
/* Updated: 2016/11/08 13:36:17 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lst_delsub(
t_list **alst,
t_list *sub,
int (*cmp)(),
void (*del)(void *, size_t))
{
t_list *tmp;
t_list **indirect;
indirect = alst;
while (*indirect)
{
if ((*cmp)((*indirect)->content, sub->content) == 0)
{
tmp = *indirect;
(*indirect) = (*indirect)->next;
ft_lstdelone(&tmp, del);
sub = sub->next;
}
indirect = &(*indirect)->next;
}
}

32
ls/libft/src/lst/ft_lst_filter.c Normal file
View file

@ -0,0 +1,32 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lst_filter.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/04 11:09:17 by jhalford #+# #+# */
/* Updated: 2016/11/21 12:36:08 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_list *ft_lst_filter(
t_list *lst,
void const *data_ref,
t_list *(*f)(t_list *elem, void const *))
{
t_list *out;
t_list *elem;
out = NULL;
while (lst)
{
elem = (*f)(lst, data_ref);
elem = ft_lstnew(elem->content, elem->content_size);
ft_lsteadd(&out, elem);
lst = lst->next;
}
return (out);
}

27
ls/libft/src/lst/ft_lst_find.c Normal file
View file

@ -0,0 +1,27 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lst_find.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/04 11:09:20 by jhalford #+# #+# */
/* Updated: 2016/11/04 11:09:20 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_list *ft_lst_find(t_list *begin_list, void *data_ref, int (*cmp)())
{
t_list *list_ptr;
list_ptr = begin_list;
while (list_ptr)
{
if ((*cmp)(list_ptr->content, data_ref) == 0)
return (list_ptr);
list_ptr = list_ptr->next;
}
return (list_ptr);
}

28
ls/libft/src/lst/ft_lst_merge.c Normal file
View file

@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_list_merge.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/08/14 13:50:32 by jhalford #+# #+# */
/* Updated: 2016/11/04 11:09:24 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lst_merge(t_list **begin_list1, t_list *begin_list2)
{
t_list *list_ptr;
if (*begin_list1)
{
list_ptr = *begin_list1;
while (list_ptr->next)
list_ptr = list_ptr->next;
list_ptr->next = begin_list2;
}
else
*begin_list1 = begin_list2;
}

41
ls/libft/src/lst/ft_lst_order_delsub.c Normal file
View file

@ -0,0 +1,41 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lst_order_delsub.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/04 11:09:25 by jhalford #+# #+# */
/* Updated: 2016/11/04 12:01:47 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lst_order_delsub(
t_list **alst,
t_list *sub,
int (*cmp)(),
void (*del)(void *, size_t))
{
t_list *tmp;
t_list **indirect;
indirect = alst;
while (*indirect)
{
if ((*cmp)((*indirect)->content, sub->content) > 0)
{
sub = sub->next;
continue ;
}
if ((*cmp)((*indirect)->content, sub->content) == 0)
{
tmp = *indirect;
(*indirect) = (*indirect)->next;
ft_lstdelone(&tmp, del);
sub = sub->next;
}
indirect = &(*indirect)->next;
}
}

25
ls/libft/src/lst/ft_lst_print.c Normal file
View file

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lst_print.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/04 11:09:27 by jhalford #+# #+# */
/* Updated: 2016/11/04 11:09:28 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lst_print(t_list *list, void (*printer)())
{
while (list)
{
ft_putstr("[");
(*printer)(list->content);
ft_putstr("]->");
list = list->next;
}
ft_putendl("X\n");
}

37
ls/libft/src/lst/ft_lst_print2.c Normal file
View file

@ -0,0 +1,37 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lst_print2.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/04 11:09:29 by jhalford #+# #+# */
/* Updated: 2016/11/04 11:09:29 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lst_print2(t_list *list, void (*printer)())
{
t_list *list2;
while (list)
{
ft_putendl("---");
list2 = *(t_list**)list->content;
while (list2)
{
ft_putstr("[");
(*printer)(*(int *)list2->content);
ft_putstr("]->");
list2 = list2->next;
}
ft_putendl("X");
ft_putendl("---");
ft_putendl(" |");
ft_putendl(" V");
list = list->next;
}
ft_putendl(" X\n");
}

33
ls/libft/src/lst/ft_lst_removeif.c Normal file
View file

@ -0,0 +1,33 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lst_removeif.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/04 11:09:30 by jhalford #+# #+# */
/* Updated: 2016/11/16 14:00:07 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_list *ft_lst_removeif(t_list **alst, void *data_ref, int (*cmp)())
{
t_list *tmp;
t_list **indirect;
indirect = alst;
while (*indirect)
{
if ((*cmp)((*indirect)->content, data_ref) == 0)
{
tmp = (*indirect);
(*indirect) = (*indirect)->next;
tmp->next = NULL;
return (tmp);
}
indirect = &(*indirect)->next;
}
return (NULL);
}

29
ls/libft/src/lst/ft_lst_reverse.c Normal file
View file

@ -0,0 +1,29 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_list_reverse.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/08/14 13:20:13 by jhalford #+# #+# */
/* Updated: 2016/11/04 11:09:34 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lst_reverse(t_list **begin_list)
{
t_list *new_start;
t_list *tmp;
new_start = NULL;
while (*begin_list)
{
tmp = (*begin_list)->next;
(*begin_list)->next = new_start;
new_start = *begin_list;
*begin_list = tmp;
}
*begin_list = new_start;
}

30
ls/libft/src/lst/ft_lst_size.c Normal file
View file

@ -0,0 +1,30 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lst_size.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/04 11:09:35 by jhalford #+# #+# */
/* Updated: 2016/11/04 11:09:36 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_lstsize(t_list *lst)
{
int i;
i = 0;
if (lst)
{
i = 1;
while (lst->next)
{
lst = lst->next;
i++;
}
}
return (i);
}

39
ls/libft/src/lst/ft_lst_sorted_insert.c Normal file
View file

@ -0,0 +1,39 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lst_sorted_insert.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/04 11:09:39 by jhalford #+# #+# */
/* Updated: 2016/11/04 11:09:39 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lst_sorted_insert(t_list **begin_list, t_list *insert, int (*cmp)())
{
t_list *link;
link = *begin_list;
if (!link || (*cmp)(insert->content, link->content) < 0)
{
*begin_list = insert;
insert->next = link ? link : NULL;
return ;
}
while (link->next)
{
if ((*cmp)(insert->content, link->content) > 0
&& (*cmp)(insert->content, link->next->content) <= 0)
{
insert->next = link->next;
link->next = insert;
return ;
}
link = link->next;
}
link->next = insert;
insert->next = NULL;
}

44
ls/libft/src/lst/ft_lst_sorted_merge.c Normal file
View file

@ -0,0 +1,44 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lst_sorted_merge.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/04 11:09:40 by jhalford #+# #+# */
/* Updated: 2016/11/04 11:09:40 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lst_sorted_merge(
t_list **begin_list1,
t_list *begin_list2,
int (*cmp)())
{
t_list *tail;
t_list *head1;
t_list *head2;
int comp;
if (!*begin_list1 || !begin_list2)
{
*begin_list1 = begin_list2 ? begin_list2 : *begin_list1;
return ;
}
comp = (*cmp)(begin_list2->content, (*begin_list1)->content);
head1 = (comp < 0) ? *begin_list1 : (*begin_list1)->next;
head2 = (comp < 0) ? begin_list2->next : begin_list2;
*begin_list1 = (comp < 0) ? begin_list2 : *begin_list1;
tail = *begin_list1;
while (head1 && head2)
{
comp = (*cmp)(head2->content, head1->content);
tail->next = (comp < 0 ? head2 : head1);
head1 = comp < 0 ? head1 : head1->next;
head2 = comp < 0 ? head2->next : head2;
tail = tail->next;
}
tail->next = head2 ? head2 : head1;
}

22
ls/libft/src/lst/ft_lstadd.c Normal file
View file

@ -0,0 +1,22 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstadd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/03 14:57:13 by jhalford #+# #+# */
/* Updated: 2016/11/04 11:09:44 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstadd(t_list **alst, t_list *new)
{
if (new)
{
new->next = *alst;
*alst = new;
}
}

23
ls/libft/src/lst/ft_lstdel.c Normal file
View file

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstdel.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/03 15:18:57 by jhalford #+# #+# */
/* Updated: 2016/11/21 14:02:16 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstdel(t_list **alst, void (*del)(void *, size_t))
{
if (alst && *alst && del)
{
ft_lstdel(&(*alst)->next, del);
ft_lstdelone(alst, del);
*alst = NULL;
}
}

24
ls/libft/src/lst/ft_lstdelone.c Normal file
View file

@ -0,0 +1,24 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstdelone.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/03 14:57:15 by jhalford #+# #+# */
/* Updated: 2016/11/21 14:02:31 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstdelone(t_list **alst, void (*del)(void *, size_t))
{
if (alst && *alst)
{
if (del)
(*del)((*alst)->content, (*alst)->content_size);
free(*alst);
*alst = NULL;
}
}

28
ls/libft/src/lst/ft_lsteadd.c Normal file
View file

@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lsteadd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/03 14:57:17 by jhalford #+# #+# */
/* Updated: 2016/11/04 13:11:05 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lsteadd(t_list **alst, t_list *new)
{
t_list *lst;
lst = *alst;
if (lst)
{
while (lst->next)
lst = lst->next;
lst->next = new;
}
else
*alst = new;
}

22
ls/libft/src/lst/ft_lstiter.c Normal file
View file

@ -0,0 +1,22 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstiter.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/03 14:57:19 by jhalford #+# #+# */
/* Updated: 2016/11/03 14:57:19 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstiter(t_list *lst, void (*f)(t_list *elem))
{
while (lst)
{
(*f)(lst);
lst = lst->next;
}
}

21
ls/libft/src/lst/ft_lstlast.c Normal file
View file

@ -0,0 +1,21 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstlast.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/04 11:09:48 by jhalford #+# #+# */
/* Updated: 2016/11/04 11:09:49 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_list *ft_lstlast(t_list *lst)
{
if (lst)
while (lst->next)
lst = lst->next;
return (lst);
}

29
ls/libft/src/lst/ft_lstmap.c Normal file
View file

@ -0,0 +1,29 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstmap.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/03 14:57:21 by jhalford #+# #+# */
/* Updated: 2016/11/04 13:11:19 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_list *ft_lstmap(t_list *lst, t_list *(*f)(t_list *elem))
{
t_list *out;
t_list *elem;
out = NULL;
while (lst)
{
elem = (*f)(lst);
elem = ft_lstnew(elem->content, elem->content_size);
ft_lsteadd(&out, elem);
lst = lst->next;
}
return (out);
}

35
ls/libft/src/lst/ft_lstnadd.c Normal file
View file

@ -0,0 +1,35 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstnadd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/04 11:09:51 by jhalford #+# #+# */
/* Updated: 2016/11/04 11:09:52 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstnadd(t_list **alst, t_list *new, int n)
{
t_list *lst;
int i;
lst = *alst;
if (lst)
{
i = 0;
while (lst->next && i < n)
{
lst = lst->next;
i++;
}
while (lst->next)
lst = lst->next;
lst->next = new;
}
else
*alst = new;
}

34
ls/libft/src/lst/ft_lstnew.c Normal file
View file

@ -0,0 +1,34 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstnew.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/03 14:57:24 by jhalford #+# #+# */
/* Updated: 2016/11/03 14:57:24 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_list *ft_lstnew(void const *content, size_t content_size)
{
t_list *new;
if (!(new = (t_list *)malloc(sizeof(*new))))
return (NULL);
new->next = NULL;
if (!content)
{
new->content_size = 0;
new->content = NULL;
}
else
{
new->content_size = content_size;
new->content = ft_memalloc(content_size + 1);
ft_memcpy(new->content, content, content_size);
}
return (new);
}

28
ls/libft/src/lst/ft_lstnew_range.c Normal file
View file

@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstnew_range.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/04 11:09:54 by jhalford #+# #+# */
/* Updated: 2016/11/04 11:09:54 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_list *ft_lstnew_range(int a, int b)
{
t_list *lst;
if (a >= b)
return (NULL);
lst = NULL;
while (a < b)
{
b--;
ft_lstadd(&lst, ft_lstnew(&b, sizeof(int)));
}
return (lst);
}

23
ls/libft/src/lst/ft_lstpop.c Normal file
View file

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstpop.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/04 11:09:56 by jhalford #+# #+# */
/* Updated: 2016/11/04 11:09:56 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
t_list *ft_lstpop(t_list **lst)
{
t_list *top;
top = *lst;
if (*lst)
*lst = (*lst)->next;
return (top);
}

38
ls/libft/src/lst/ft_lstsort.c Normal file
View file

@ -0,0 +1,38 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lstsort.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/04 11:09:58 by jhalford #+# #+# */
/* Updated: 2016/11/23 15:43:48 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_lstsort(t_list **begin_list, int (*cmp)())
{
t_list **indirect;
t_list *tmp;
t_list *tmp2;
indirect = begin_list;
if (!*begin_list)
return ;
while (*indirect && (*indirect)->next)
{
if ((*cmp)((*indirect)->content, (*indirect)->next->content) > 0)
{
tmp = *indirect;
tmp2 = (*indirect)->next;
(*indirect)->next = (*indirect)->next->next;
*indirect = tmp2;
(*indirect)->next = tmp;
indirect = begin_list;
}
else
indirect = &(*indirect)->next;
}
}

18
ls/libft/src/math/ft_addrcmp.c Normal file
View file

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_addrcmp.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/14 15:59:10 by jhalford #+# #+# */
/* Updated: 2016/11/14 15:59:39 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int ft_addrcmp(void *a, void *b)
{
return (a - b);
}

23
ls/libft/src/math/ft_ilen.c Normal file
View file

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_ilen.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:53:53 by jhalford #+# #+# */
/* Updated: 2016/11/07 14:44:35 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
size_t ft_ilen(int n)
{
size_t i;
i = 1;
while (n /= 10)
i++;
return (i);
}

23
ls/libft/src/math/ft_ilen_base.c Normal file
View file

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_ilen_base.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:53:53 by jhalford #+# #+# */
/* Updated: 2016/11/07 14:45:28 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
size_t ft_ilen_base(int n, int base)
{
size_t i;
i = 1;
while (n /= base)
i++;
return (i);
}

49
ls/libft/src/math/ft_itoa.c Normal file
View file

@ -0,0 +1,49 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_itoa.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/03 14:57:10 by jhalford #+# #+# */
/* Updated: 2016/11/04 13:11:28 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
static size_t ft_size(int n)
{
size_t i;
i = 1;
while (n /= 10)
i++;
return (i);
}
char *ft_itoa(int n)
{
int i;
char *str;
int neg;
i = 0;
str = ft_strnew(ft_size(n) + 1);
neg = FT_NEG(n) ? 1 : 0;
if (n == 0)
{
str[i++] = '0';
str[i] = '\0';
return (str);
}
while (n)
{
str[i++] = FT_ABS(n % 10) + '0';
n /= 10;
}
if (neg)
str[i++] = '-';
str[i] = '\0';
return (ft_strrev(str));
}

51
ls/libft/src/math/ft_itoa_base.c Normal file
View file

@ -0,0 +1,51 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_itoa_base.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:52:51 by jhalford #+# #+# */
/* Updated: 2016/11/07 14:45:15 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
static char *ft_flags(char *str, int *i, char *flags, int neg)
{
if (neg)
str[*i++] = '-';
else if (ft_strchr(flags, '+'))
str[*i++] = '+';
else if (ft_strchr(flags, ' '))
str[*i++] = ' ';
return (str);
}
char *ft_itoa_base(int nbr, char *base, char *flags)
{
int i;
int neg;
int base_size;
char *str;
i = 0;
base_size = ft_strlen(base);
str = ft_strnew(ft_ilen_base(nbr, base_size) + 1);
neg = FT_NEG(nbr);
if (nbr == 0)
{
str[i++] = '0';
str[i] = '\0';
return (str);
}
while (nbr)
{
str[i++] = base[FT_ABS(nbr % base_size)];
nbr = nbr / base_size;
}
str = ft_flags(str, &i, flags, neg);
str[i] = '\0';
return (ft_strrev(str));
}

23
ls/libft/src/math/ft_lllen.c Normal file
View file

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lllen.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:52:35 by jhalford #+# #+# */
/* Updated: 2016/11/07 14:45:40 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
size_t ft_lllen(long long n)
{
size_t i;
i = 1;
while (n /= 10)
i++;
return (i);
}

23
ls/libft/src/math/ft_lllen_base.c Normal file
View file

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lllen_base.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:52:35 by jhalford #+# #+# */
/* Updated: 2016/11/07 14:46:15 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
size_t ft_lllen_base(long long n, int base)
{
size_t i;
i = 1;
while (n /= base)
i++;
return (i);
}

52
ls/libft/src/math/ft_lltoa_base.c Normal file
View file

@ -0,0 +1,52 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lltoa_base.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:10:42 by jhalford #+# #+# */
/* Updated: 2016/11/07 16:30:42 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
static char *ft_flags(char *str, int *i, char *flags, int neg)
{
if (neg)
str[*i++] = '-';
else if (ft_strchr(flags, '+'))
str[*i++] = '+';
else if (ft_strchr(flags, ' '))
str[*i++] = ' ';
return (str);
}
char *ft_lltoa_base(long long nbr, char *base, char *flags)
{
int i;
int neg;
int base_size;
char *str;
i = 0;
base_size = ft_strlen(base);
str = ft_strnew(ft_lllen_base(nbr, base_size) + 1);
neg = FT_NEG(nbr);
if (nbr == 0)
{
str[i++] = '0';
str[i] = '\0';
return (str);
}
while (nbr)
{
str[i++] = base[FT_ABS(nbr % base_size)];
nbr = nbr / base_size;
}
str = ft_flags(str, &i, flags, neg);
str[i] = '\0';
ft_strrev(str);
return (str);
}

23
ls/libft/src/math/ft_uilen.c Normal file
View file

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_uilen.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:52:35 by jhalford #+# #+# */
/* Updated: 2016/11/07 13:54:41 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
size_t ft_uilen(unsigned int n)
{
size_t i;
i = 1;
while (n /= 10)
i++;
return (i);
}

47
ls/libft/src/math/ft_uitoa_base.c Normal file
View file

@ -0,0 +1,47 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_uitoa_base.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:08:10 by jhalford #+# #+# */
/* Updated: 2016/11/07 13:10:35 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
static size_t ft_size(unsigned int n, int base)
{
size_t i;
i = 1;
while (n /= base)
i++;
return (i);
}
char *ft_uitoa_base(unsigned int nbr, char *base)
{
int i;
int base_size;
char *str;
i = 0;
base_size = ft_strlen(base);
str = ft_strnew(ft_size(nbr, base_size) + 1);
if (nbr == 0)
{
str[i++] = '0';
str[i] = '\0';
return (str);
}
while (nbr)
{
str[i++] = base[nbr % base_size];
nbr = nbr / base_size;
}
str[i] = '\0';
return (ft_strrev(str));
}

47
ls/libft/src/math/ft_ulltoa_base.c Normal file
View file

@ -0,0 +1,47 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_ulltoa_base.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/07 13:07:50 by jhalford #+# #+# */
/* Updated: 2016/11/07 13:12:41 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
static size_t ft_size(unsigned long long n, int base)
{
size_t i;
i = 1;
while (n /= base)
i++;
return (i);
}
char *ft_ulltoa_base(unsigned long long nbr, char *base)
{
int i;
int base_size;
char *str;
i = 0;
base_size = ft_strlen(base);
str = ft_strnew(ft_size(nbr, base_size) + 1);
if (nbr == 0)
{
str[i++] = '0';
str[i] = '\0';
return (str);
}
while (nbr)
{
str[i++] = base[nbr % base_size];
nbr = nbr / base_size;
}
str[i] = '\0';
return (ft_strrev(str));
}

22
ls/libft/src/mem/ft_bzero.c Normal file
View file

@ -0,0 +1,22 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_bzero.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/03 14:56:08 by jhalford #+# #+# */
/* Updated: 2016/11/03 14:56:09 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_bzero(void *s, size_t n)
{
size_t i;
i = -1;
while (++i < n)
*(char *)s++ = 0;
}

27
ls/libft/src/mem/ft_memalloc.c Normal file
View file

@ -0,0 +1,27 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_memalloc.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/03 14:57:25 by jhalford #+# #+# */
/* Updated: 2016/11/11 17:40:57 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void *ft_memalloc(size_t size)
{
void *addr;
size_t i;
addr = malloc(size);
if (addr == NULL)
return (NULL);
i = -1;
while (++i < size)
((char *)addr)[i] = 0;
return (addr);
}

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