Houtworm/cub3d
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

initial push

Browse Source
This commit is contained in:
Danny Jonker 2023-10-25 13:56:45 +02:00
commit ecb0a9a77d
781 changed files with 47507 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
Makefile Normal file
View File

@ -0,0 +1,72 @@
# **************************************************************************** #
# #
# .--. _ #
# Makefile :+: :+: #
# |:_/ || |_ _ ___ __ #
# By: djonker <djonker@student.codam.nl> // \ \ __| | | \ \/ / #
# (| | )|_| |_| |> < #
# Created: 2022/11/24 10:12:10 by djonker /'\_ _/`\__|\__,_/_/\_\ #
# Updated: 2023/10/25 13:53:30 by djonker ######## odam.nl #
# #
# **************************************************************************** #
NAME =fract-ol
CC =gcc
FC =-Wall -Werror -Wextra -Wunreachable-code -Ofast #-fsanitize=address
HEAD =-I ./include -I $(MLX)/include
RM =rm -rf
UNAME_S :=$(shell uname -s)
ifeq ($(UNAME_S),Linux)
OS =Freedom Respecting Linux! :)
LIB =libft/libft.a mlx/build/libmlx42.a -ldl -lglfw -pthread -lm
else
OS =Proprietary Malware :(
LIB =libft/libft.a mlx/build/libmlx42.a -lglfw3 -framework Cocoa -framework OpenGL -framework IOKit
endif
SRC =src/main.c\
src/colors.c\
src/zoommove.c\
src/keyhooks.c\
src/mousehooks.c\
src/print.c\
src/error.c\
src/fractal.c\
src/fractals1.c\
src/fractals2.c
OBJ =$(SRC:src/%.c=obj/%.o)
all: libft libmlx $(NAME)
clean:
@$(RM) -r obj
@$(MAKE) -C libft clean > /dev/null
@$(MAKE) -C mlx/build clean > /dev/null
@printf "\e[1;35mCleaned Object Files\n\e[0;00m"
fclean: clean
@$(RM) $(NAME) mlx/build
@$(MAKE) -C libft fclean > /dev/null
@printf "\e[1;31mCleaned Executables\n\e[0;00m"
re: fclean all
$(OBJ): $(SRC)
@mkdir -p $(dir $@)
@printf "\e[1;34mBuilding $@\n\e[0;00m"
@$(CC) $(CFLAGS) -c $(@:obj/%.o=src/%.c) -o $@
$(NAME): $(OBJ)
@printf "\e[1;36mCompiling $@\e[0;00m\n"
@$(CC) $(FC) -o $(NAME) $(SRC) $(LIB) $(HEAD)
@printf "\e[1;32mDone\e[0;00m\n"
libft:
@$(MAKE) -C libft all
libmlx:
@cd mlx
@cmake -S mlx -B mlx/build
@$(MAKE) -C mlx/build -j4
@cd ..
.PHONY: libft

33
Readme.md Normal file
View File

@ -0,0 +1,33 @@
# Fractol
Fractol is a Fractal zoomer using the mlx library
---
## Improvements
### Features
auto zoom to current center.\
Seperate Calculation from drawing so that color flowing can be controlled without recalculating\
calulate and display fractal dimension?, count edge pixels at standard zoom?\
option to display numbers of the numberplane?, if so how to shrink with zoom?\
add an option to blend colors in a gradient\
vector graphic fractols based on lines if possible?
### Faster Rendering
multithreading, give every Y line to the next thread.\
If both numbers get very close to zero it is definitely in the mandelbrot (mess up precision?)\
Check if the last number is very close to the current number every 10 iterations, if so break, it is in the mandelbrot (mess up precision?)\
Use Symmetric properties to draw the first line and last line at the same time (only helpful with very low zoom values else it only adds conditions.)\
Somehow stop calculating if a new calculation is next in line\
Edge Detection?
---
## Bugs
**fractal getting out of aspect when wildly zooming in and out**\
**CY and CX value wrong when the doubles are negative**
---
## Usage
1. Simply clone or download the repository
2. Run `make` in the cloned directory
3. Start the server with `./fract-ol [FRACTAL] [ITERATIONS] [COLORSCHEME]`
---
[This project is part of the studies at 42](https://42.fr/en/homepage/)

96
fractol.h Normal file
View File

@ -0,0 +1,96 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* fractol.h |o_o || | */
/* +:+ +:+ +:+ */
/* By: houtworm <codam@houtworm.net> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/11/29 03:25:46 by houtworm #+# #+# */
/* Updated: 2022/12/29 06:29:04 by djonker \___)=(___/ */
/* */
/* ************************************************************************** */
#ifndef FRACTOL_H
# define FRACTOL_H
# include <unistd.h>
# include <math.h>
# include "libft/libft.h"
# include "mlx/include/MLX42/MLX42.h"
typedef struct s_cnbr
{
long double re; //Real Number
long double im; //Imaginary Number
} t_cnbr;
typedef struct s_varlist
{
mlx_t *mlx; //mlx instance
mlx_image_t *img; //mlx img
mlx_image_t *font[30]; //mlx font image
int w; //actual window width used everywhere
int h; //actual window height used everywhere
int fontnbr; //number printed strings on the screen
char *fractal; //name of fractal used for title and info
int fractalid; //int id of the fractal to faster compare
char *cscheme; //name of current colorscheme to print
int cschemeid; //id of current colorscheme to compare
int cscale; //scale used to generate colorschemes
int cshi; //used for shifting colors by 1
int csha; //total amount of colors/shades
int32_t colors[1530]; //colorscheme colors
int iter; //number of iterations to do
long long calc; //Number of calculations per frame
long double xmax; //max number shown on the horizontal numberplane
long double ymax; //max number shown on the vertical numberplane
long double xmin; //min number shown on the horizontal numberplane
long double ymin; //min number shown on the vertical numberplane
long double xscale; //scale of visible numbers horizontal numberplane
long double yscale; //scale of visible numbers vertical numberplane
long double julre; //adjustable c value for x axis
long double julim; //adjustable c value for y axis
int xcur; //current x position of the mouse
int ycur; //current y position of the mouse
int psycho; //psycho mode toggle
int help; //help screen toggle
int info; //info screen toggle
int redraw; //if true then redraw
long double power; //for the mandelpower
} t_varlist;
typedef struct s_threads
{
t_varlist *vl;
int x;
int y;
} t_threads;
void mousehook(void *param);
void scrollhook(double xdelta, double ydelta, void *param);
void keyhook(mlx_key_data_t keydata, void *param);
void keyhookextra(void *param);
void keyhookmove(void *param);
void keyhookfractal(void *param);
void resizehook(int x, int y, void *param);
void setcolorscheme(t_varlist *vl);
void redrawimage(t_varlist *vl);
void resetfractal(t_varlist *vl);
void ft_error(int r);
void showinfo(t_varlist *vl);
void showhelp(t_varlist *vl);
void justmove(t_varlist *vl, char dir);
void zoomtomouse(t_varlist *vl);
void zoomfrommouse(t_varlist *vl);
void fractal(t_varlist *vl);
void mandelbrot(t_varlist *vl, int x, int y, t_cnbr c);
void mandelcloud(t_varlist *vl, int x, int y, t_cnbr c);
void mandelfeather(t_varlist *vl, int x, int y, t_cnbr c);
void julia(t_varlist *vl, int x, int y, t_cnbr z);
void mandelpower(t_varlist *vl, int x, int y, t_cnbr c);
void burningship(t_varlist *vl, int x, int y, t_cnbr c);
void tricorn(t_varlist *vl, int x, int y, t_cnbr c);
void rorschach(t_varlist *vl, int x, int y, t_cnbr c);
void powerflower(t_varlist *vl, int x, int y, t_cnbr c);
#endif

8
libft/.gitignore vendored Normal file
View File

@ -0,0 +1,8 @@
*.pdf
*.o
*.a
LICENSE
obj
tests/tmp
.git
.ccls-cache

185
libft/Makefile Normal file
View File

@ -0,0 +1,185 @@
# **************************************************************************** #
# #
# :::::::: #
# Makefile |o_o || | #
# +:+ #
# By: djonker <marvin@codam.nl> +#+ #
# +#+ #
# Created: 2020/10/27 15:02:02 by djonker #+# #+# #
# Updated: 2023/02/23 15:40:38 by houtworm \___)=(___/ #
# #
# **************************************************************************** #
NAME =libft.a
CC =gcc
FC =-Wall -Werror -Wextra -fsanitize=address
FAR =ar -rs
RM =rm -f
SRC =src/ft_atoi.c \
src/ft_bzero.c \
src/ft_calloc.c \
src/ft_cntwrd.c \
src/ft_intlen.c \
src/ft_isalnum.c \
src/ft_isalpha.c \
src/ft_isascii.c \
src/ft_isdigit.c \
src/ft_isprint.c \
src/ft_itoa.c \
src/ft_malstr.c \
src/ft_memccpy.c \
src/ft_memchr.c \
src/ft_memcmp.c \
src/ft_memmove.c \
src/ft_memcpy.c \
src/ft_memset.c \
src/ft_putchar_fd.c \
src/ft_putendl_fd.c \
src/ft_putnbr_fd.c \
src/ft_putstr_fd.c \
src/ft_split.c \
src/ft_strchr.c \
src/ft_strdup.c \
src/ft_strjoin.c \
src/ft_strlcat.c \
src/ft_strlcpy.c \
src/ft_strlen.c \
src/ft_strmapi.c \
src/ft_strncmp.c \
src/ft_strnstr.c \
src/ft_strrchr.c \
src/ft_strtrim.c \
src/ft_substr.c \
src/ft_tolower.c \
src/ft_toupper.c \
src/ft_wrdlen.c \
src/ft_frenarr.c \
src/ft_btoi.c \
src/ft_itob.c \
src/ft_revstr.c \
src/ft_frearr.c \
src/ft_putznbr.c \
src/ft_strupp.c \
src/ft_strlow.c \
src/ft_power.c \
src/ft_sqrt.c \
src/ft_factor.c \
src/ft_fnprim.c \
src/ft_isprim.c \
src/ft_dtoh.c \
src/ft_htod.c \
src/ft_htoi.c \
src/ft_itoh.c \
src/ft_ddtoi.c \
src/ft_itodd.c \
src/ft_otoi.c \
src/ft_itoo.c \
src/ft_swap.c \
src/ft_swaplong.c \
src/ft_round.c \
src/ft_putznbr_fd.c \
src/ft_putzflo_fd.c \
src/ft_putzflo.c \
src/ft_putstr.c \
src/ft_putnbr.c \
src/ft_putnbr_base.c \
src/ft_putflo.c \
src/ft_putendl.c \
src/ft_putchar.c \
src/ft_linlen.c \
src/ft_itof.c \
src/ft_isneg.c \
src/ft_iftof.c \
src/ft_ftoi.c \
src/ft_ftoa.c \
src/ft_fround.c \
src/ft_flolen.c \
src/ft_declen.c \
src/ft_atof.c \
src/ft_putflo_fd.c \
src/ft_arrlen.c \
src/ft_chrstr.c \
src/ft_cntwrds.c \
src/ft_isodigit.c \
src/ft_isxdigit.c \
src/ft_malstrs.c \
src/ft_min.c \
src/ft_max.c \
src/ft_lincpy.c \
src/ft_linlcpy.c \
src/ft_splits.c \
src/ft_wrdlens.c \
src/ft_vamin.c \
src/ft_vamax.c \
src/ft_islowc.c \
src/ft_isuppc.c \
src/ft_bitswap.c \
src/ft_itozh.c \
src/ft_itoba.c \
src/ft_itohx.c \
src/ft_cntchr.c \
src/ft_cntarg.c \
src/ft_around.c \
src/ft_putzsci.c \
src/ft_putull.c \
src/ft_putlong.c \
src/ft_ltoa.c \
src/ft_utoa.c \
src/ft_atou.c \
src/ft_atol.c \
src/ft_putzscih.c \
src/ft_luilen.c \
src/ft_itooa.c \
src/ft_dtoa.c \
src/ft_atodec.c \
src/ft_fczero.c \
src/ft_lftoi.c \
src/ft_lftoa.c \
src/ft_islneg.c \
src/ft_ldeclen.c \
src/ft_isallbyte.c \
src/ft_getpwd.c
BSRC =src/ft_lstadd_back.c \
src/ft_lstadd_front.c \
src/ft_lstclear.c \
src/ft_lstdelone.c \
src/ft_lstiter.c \
src/ft_lstlast.c \
src/ft_lstmap.c \
src/ft_lstnew.c \
src/ft_lstsize.c
OBJ =$(SRC:src/%.c=obj/%.o)
BOBJ =$(BSRC:src/%.c=obj/%.o)
ifdef WITBON
COBJ =$(OBJ) $(BOBJ)
CSRC =$(SRC) $(BSRC)
else
COBJ =$(OBJ)
CSRC =$(SRC)
endif
all: $(NAME)
clean:
@$(RM) -r obj
@printf "\e[1;35mCleaned Object Files\n\e[0;00m"
fclean: clean
@$(RM) $(NAME)
@printf "\e[1;31mCleaned Executables\n\e[0;00m"
re: fclean all
$(COBJ): $(CSRC)
@mkdir -p $(dir $@)
@printf "\e[1;34mBuilding $@\n\e[0;00m"
@$(CC) $(CFLAGS) -c $(@:obj/%.o=src/%.c) -o $@
$(NAME): $(COBJ)
@printf "\e[1;36mCompiling $@\e[0;00m\n"
@$(FAR) $(NAME) $^ > /dev/null 2>&1
@printf "\e[1;32mDone\e[0;00m\n"
bonus:
@$(MAKE) WITBON=1 all

10
libft/Readme.md Normal file
View File

@ -0,0 +1,10 @@
# Functions
## striteri
void ft_striteri(char *s, void (*f)(unsigned int, char*));
# Tester
## general
check for -Wall -Werror -Wextra
Think of more edge cases for all functions
## add tests extra
check if function exists in .h and run the tests for that fucntion

164
libft/libft.h Normal file
View File

@ -0,0 +1,164 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* libft.h |o_o || | */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/11 16:02:53 by djonker #+# #+# */
/* Updated: 2023/03/05 20:30:31 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#ifndef LIBFT_H
# define LIBFT_H
# include <unistd.h>
# include <stdlib.h>
# include <stdarg.h>
typedef struct s_list
{
void *content;
struct s_list *next;
} t_list;
void *ft_memset(void *s, int c, size_t n);
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 *str);
size_t ft_strlcpy(char *dst, const char *src, size_t dstsize);
size_t ft_strlcat(char *dst, const char *src, size_t dstsize);
char *ft_strchr(const char *s, int c);
char *ft_strrchr(const char *s, int c);
char *ft_strnstr(const char *h, const char *n, size_t len);
int ft_strncmp(char *s1, char *s2, unsigned int n);
int ft_atoi(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_calloc(size_t count, size_t size);
char *ft_strdup(const char *s);
char *ft_substr(char const *s, unsigned int start, size_t len);
char *ft_strjoin(char const *s1, char const *s2);
char *ft_strtrim(char const *s1, char const *set);
char **ft_split(char const *s, char c);
char *ft_itoa(int n);
char *ft_strmapi(char const *s, char (*f)(unsigned int, char));
void ft_putchar_fd(char s, int fd);
void ft_putstr_fd(char *s, int fd);
void ft_putendl_fd(char *s, int fd);
void ft_putnbr_fd(int n, int fd);
t_list *ft_lstnew(void *content);
void ft_lstadd_front(t_list **lst, t_list *new);
int ft_lstsize(t_list *lst);
t_list *ft_lstlast(t_list *lst);
void ft_lstadd_back(t_list **lst, t_list *new);
void ft_lstdelone(t_list *lst, void (*del)(void*));
void ft_lstclear(t_list **lst, void (*del)(void*));
void ft_lstiter(t_list *lst, void (*f)(void *));
t_list *ft_lstmap(t_list *lst, void *(*f)(void *), \
void (*del)(void *));
char *ft_bitswap(char *str);
void *ft_lincpy(char *dst, const char *src);
void *ft_linlcpy(char *dst, const char *src, size_t n);
int ft_linlen(char *str);
int ft_intlen(long long n);
int ft_luilen(unsigned long long n);
int ft_flolen(double n);
int ft_arrlen(char **s);
int ft_declen(double n);
int ft_wrdlen(char *s, char c, int i);
int ft_wrdlens(char *s, char *c, int i);
int ft_cntwrd(char *s, char c);
int ft_cntwrds(char *s, char *c);
char *ft_malstr(char *s, char c);
char *ft_malstrs(char *s, char *c);
void *ft_frenarr(char **s, int i);
void *ft_frearr(char **s);
char *ft_revstr(char *s);
char *ft_strupp(char *s);
char *ft_strlow(char *s);
int ft_isuppc(char c);
int ft_islowc(char c);
int ft_isneg(double n);
int ft_isxdigit(char *str);
int ft_isodigit(int n);
int ft_power(int n, int p);
unsigned long long ft_sqrt(unsigned long long n);
unsigned long long ft_factor(unsigned long long n);
unsigned long long ft_fnprim(unsigned long long n);
int ft_isprim(unsigned long long n);
void ft_putznbr_fd(int n, int e, int fd);
void ft_putflo_fd(double n, int fd);
void ft_putzflo_fd(double n, int e, int fd);
int ft_ftoi(double n);
double ft_itof(int n);
double ft_iftof(int n, int f);
char *ft_ltoa(long long n);
char *ft_utoa(unsigned long long n);
char *ft_ftoa(double n);
char *ft_ftoe(double n);
long long ft_atol(char *str);
unsigned long long ft_atou(char *str);
double ft_atof(char *str);
long double ft_atodec(char *str);
int ft_itob(int d);
char *ft_itoba(unsigned long long d, size_t e);
int ft_btoi(int i, int e);
int ft_dtoh(char c);
char ft_htod(long long n);
int ft_htoi(char *str);
char *ft_itoh(long double n);
char *ft_itohx(long double n);
char *ft_itozh(double n, int z);
int ft_ddtoi(char *str);
char *ft_itodd(double n);
int ft_otoi(int i);
unsigned long long ft_itoo(double n);
char *ft_itooa(long double n);
int ft_round(int n, int h);
double ft_fround(double n, int h);
int ft_around(char *n, int e);
void ft_swap(int *a, int *b);
void ft_swaplong(long *a, long *b);
void ft_putchar(char s);
void ft_putstr(char *s);
void ft_putendl(char *s);
void ft_putnbr(int n);
void ft_putnbr_base(unsigned long long number, int base);
void ft_putlong(long long n);
void ft_putull(unsigned long long n);
void ft_putznbr(int n, int e);
void ft_putflo(double n);
void ft_putzflo(double n, int e);
void ft_putzsci(long double n, int e, int cap);
void ft_putzscih(long double n, int e, int cap);
int ft_varlen(int c, ...);
int ft_max(int a, int b);
int ft_vamax(int n, ...);
int ft_min(int a, int b);
int ft_vamin(int n, ...);
int ft_chrstr(char c, char *s);
char **ft_splits(char *s, char *c);
int ft_cntchr(const char *str, char c, int s);
int ft_fczero(long double n);
long long ft_lftoi(long double n);
char *ft_lftoa(long double n);
int ft_ldeclen(long double n);
int ft_islneg(long long n);
char *ft_dtoa(long double n);
int ft_isallbyte(char *str, char byte);
char *ft_getpwd(char **envp, int slash);
#endif

41
libft/src/ft_around.c Normal file
View File

@ -0,0 +1,41 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_around.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/02 07:26:00 by djonker #+# #+# */
/* Updated: 2023/02/07 00:42:07 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_around(char *n, int e)
{
int i;
i = 0;
while (n[i] == '0')
{
e++;
i++;
}
i = ft_strlen(n);
while (i >= e)
{
if (n[i] >= '5')
n[i - 1] = n[i - 1] + 1;
while (n[i - 1] > '9')
{
n[i - 1] = '0';
n[i - 2] = n[i - 2] + 1;
i--;
if (i == 1 && n[0] > '9')
return (1);
}
i--;
}
return (0);
}

23
libft/src/ft_arrlen.c Normal file
View File

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_arrlen.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/06 17:38:27 by djonker #+# #+# */
/* Updated: 2023/02/07 00:42:08 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_arrlen(char **s)
{
int l;
l = 0;
while (s[l] != NULL)
l++;
return (l);
}

28
libft/src/ft_atodec.c Normal file
View File

@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_atodec.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/02 05:48:34 by djonker #+# #+# */
/* Updated: 2023/02/07 00:42:08 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
long double ft_atodec(char *str)
{
long double f;
int l;
f = ft_atoi(str);
l = ft_intlen(f);
while (l > 0)
{
f = f / 10;
l--;
}
return (f);
}

33
libft/src/ft_atof.c Normal file
View File

@ -0,0 +1,33 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_atof.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/02 05:48:34 by djonker #+# #+# */
/* Updated: 2023/02/07 00:42:08 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
double ft_atof(char *str)
{
int i;
double f;
char **t;
int l;
t = ft_split(str, '.');
f = ft_atoi(t[1]);
l = ft_intlen(f);
i = ft_atoi(t[0]);
while (l > 0)
{
f = f / 10;
l--;
}
ft_frenarr(t, 2);
return (i + f);
}

41
libft/src/ft_atoi.c Normal file
View File

@ -0,0 +1,41 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_atoi.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/01 19:08:11 by djonker #+# #+# */
/* Updated: 2023/02/07 00:42:09 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_atoi(char *str)
{
unsigned int r;
int c;
int n;
r = 0;
c = 0;
n = 1;
if (str == NULL)
return (0);
while ((str[c] == 32) || (str[c] > 8 && str[c] < 14))
c++;
if (str[c] == '-' || str[c] == '+')
if (str[c++] == '-')
n = -1;
while (str[c] >= '0' && str[c] <= '9')
{
r = 10 * r + (str[c] - '0');
if (r > 2147483647 && n == 1)
return (-1);
else if (r > 2147483648 && n == -1)
return (0);
c++;
}
return (n * r);
}

42
libft/src/ft_atol.c Normal file
View File

@ -0,0 +1,42 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_atol.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/01 19:08:11 by djonker #+# #+# */
/* Updated: 2023/02/07 00:36:46 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
long long ft_atol(char *str)
{
unsigned long long r;
int c;
int n;
r = 0;
c = 0;
n = 1;
while ((str[c] == 32) || (str[c] > 8 && str[c] < 14))
c++;
if (str[c] == '-' || str[c] == '+')
{
if (str[c] == '-')
n = -1;
c++;
}
while (str[c] >= '0' && str[c] <= '9')
{
r = 10 * r + (str[c] - '0');
if (r > 9223372036854775807 && n == 1)
return (-1);
else if (r > 9223372036854775807 && n == -1)
return (0);
c++;
}
return (n * r);
}

31
libft/src/ft_atou.c Normal file
View File

@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_atou.c |o_o || | */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/01 19:08:11 by djonker #+# #+# */
/* Updated: 2023/03/05 21:13:18 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
unsigned long long ft_atou(char *str)
{
unsigned long long r;
int c;
r = 0;
c = 0;
while ((str[c] == 32) || (str[c] > 8 && str[c] < 14))
c++;
while (str[c] >= '0' && str[c] <= '9')
{
r = 10 * r + (str[c] - '0');
c++;
}
free (str);
return (r);
}

26
libft/src/ft_bitswap.c Normal file
View File

@ -0,0 +1,26 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_bitswap.c :+: :+: :+: */
/* +:+ */
/* By: djonker <djonker@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2021/05/17 06:29:44 by djonker #+# #+# */
/* Updated: 2023/02/07 00:38:18 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
char *ft_bitswap(char *str)
{
while (*str)
{
if (*str == '1')
*str = '0';
else if (*str == '0')
*str = '1';
str++;
}
return (str);
}

42
libft/src/ft_btoi.c Normal file
View File

@ -0,0 +1,42 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_btoi.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/01/18 13:44:56 by djonker #+# #+# */
/* Updated: 2023/02/07 00:36:46 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_btoi(int i, int e)
{
char *s;
int is;
int it;
int d;
int r;
d = ft_intlen(i);
it = 128;
is = 0;
r = 0;
while (d < e)
{
it = it / 2;
d++;
}
s = ft_itoa(i);
while (s[is] != '\0')
{
if (s[is] == '1')
r = r + it;
it = it / 2;
is++;
}
free(s);
return (r);
}

28
libft/src/ft_bzero.c Normal file
View File

@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_bzero.c |o_o || | */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/01 08:35:25 by djonker #+# #+# */
/* Updated: 2023/02/22 02:01:25 by djonker \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
void ft_bzero(void *s, size_t n)
{
char *p;
if (!s || n <= 0)
return ;
p = s;
while (n)
{
*p = '\0';
p++;
n--;
}
}

40
libft/src/ft_calloc.c Normal file
View File

@ -0,0 +1,40 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_calloc.c |o_o || | */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/01 21:20:32 by djonker #+# #+# */
/* Updated: 2023/02/25 16:18:01 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
void *ft_calloc(size_t count, size_t size)
{
void *p;
size_t i;
char *t;
if (count == 0 || size == 0)
{
count = 1;
size = 1;
}
p = malloc(count * size);
if (p == NULL)
return (0x0);
if (p)
{
t = p;
i = 0;
while (count * size > i)
{
t[i] = '\0';
i++;
}
}
return (p);
}

26
libft/src/ft_chrstr.c Normal file
View File

@ -0,0 +1,26 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_chrstr.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/15 02:30:48 by djonker #+# #+# */
/* Updated: 2023/02/07 00:36:47 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_chrstr(char c, char *s)
{
while (*s)
{
if (c == *s)
return (1);
s++;
}
if (c == *s)
return (1);
return (0);
}

23
libft/src/ft_cntarg.c Normal file
View File

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_cntarg.c |o_o || | */
/* +:+ +:+ +:+ */
/* By: houtworm <codam@houtworm.net> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/07 00:38:26 by houtworm #+# #+# */
/* Updated: 2023/02/21 01:43:17 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_cntarg(char **argv)
{
int i;
i = 0;
while (argv[i])
i++;
return (i);
}

36
libft/src/ft_cntchr.c Normal file
View File

@ -0,0 +1,36 @@
/* ************************************************************************** */
/* */
/* .--. _ */
/* ft_cntchr.c :+: :+: :+: */
/* |:_/ || |_ _ ___ __ */
/* By: djonker <djonker@student.codam.nl> // \ \ __| | | \ \/ / */
/* (| | )|_| |_| |> < */
/* Created: 2021/06/11 17:23:36 by djonker /'\_ _/`\__|\__,_/_/\_\ */
/* Updated: 2023/02/07 00:38:41 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_cntchr(const char *str, char c, int s)
{
int i;
int t;
i = 0;
while (*str)
{
if (*str == c)
{
i++;
str++;
}
t = s;
while (t > 0)
{
str++;
t--;
}
}
return (i);
}

35
libft/src/ft_cntwrd.c Normal file
View File

@ -0,0 +1,35 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_cntwrd.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/21 20:37:04 by djonker #+# #+# */
/* Updated: 2023/02/07 00:38:43 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_cntwrd(char *s, char c)
{
int iw;
int is;
is = 0;
iw = 0;
while (s[is] != '\0')
{
if (s[is] == c)
while (s[is] == c)
is++;
if (s[is] != c && s[is] != '\0')
{
while (s[is] != c && s[is] != '\0')
is++;
iw++;
}
}
return (iw);
}

35
libft/src/ft_cntwrds.c Normal file
View File

@ -0,0 +1,35 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_cntwrds.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/21 20:37:04 by djonker #+# #+# */
/* Updated: 2023/02/07 00:38:44 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_cntwrds(char *s, char *c)
{
int iw;
int is;
is = 0;
iw = 0;
while (s[is] != '\0')
{
if (ft_chrstr(s[is], c))
while (ft_chrstr(s[is], c))
is++;
if (!(ft_chrstr(s[is], c)))
{
while (!(ft_chrstr(s[is], c)))
is++;
iw++;
}
}
return (iw);
}

34
libft/src/ft_ddtoi.c Normal file
View File

@ -0,0 +1,34 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_ddtoi.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/01/31 01:24:28 by djonker #+# #+# */
/* Updated: 2023/02/07 00:38:44 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_ddtoi(char *str)
{
int r;
int p;
r = 0;
p = ft_strlen(str) - 1;
while (p >= 0)
{
if (*str >= '0' && *str <= '9')
r = r + (*str - '0') * ft_power(12, p);
else if ((*str >= 'a' && *str <= 'b') || (*str >= 'A' && *str <= 'B'))
r = r + ft_dtoh(*str) * ft_power(12, p);
else
return (-0);
str++;
p--;
}
return (r);
}

32
libft/src/ft_declen.c Normal file
View File

@ -0,0 +1,32 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_declen.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/02 04:29:09 by djonker #+# #+# */
/* Updated: 2023/02/07 00:38:45 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_declen(double n)
{
double f;
int i;
int l;
i = n;
f = n - i;
l = 0;
while (f != 0 && l < 10)
{
l++;
n = n * 10;
i = n;
f = n - i;
}
return (l);
}

38
libft/src/ft_dtoa.c Normal file
View File

@ -0,0 +1,38 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_dtoa.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/02 03:46:17 by djonker #+# #+# */
/* Updated: 2023/02/07 00:38:46 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
char *ft_dtoa(long double n)
{
char p[100];
long double temp;
long long i;
char *t;
char *f;
i = n;
temp = (long double)n - (long double)i;
i = 0;
while (temp * 10 < 1 && i < 49)
{
temp = temp * 10;
p[i] = '0';
i++;
}
p[i] = '\0';
i = ft_lftoi(n);
t = ft_ltoa(i);
f = ft_strjoin(p, t);
free(t);
return (f);
}

23
libft/src/ft_dtoh.c Normal file
View File

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_dtoh.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/01/31 02:22:34 by djonker #+# #+# */
/* Updated: 2023/02/07 00:38:47 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_dtoh(char c)
{
int r;
int t;
t = ft_tolower(c);
r = t - 87;
return (r);
}

25
libft/src/ft_factor.c Normal file
View File

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_factor.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/01 04:03:20 by djonker #+# #+# */
/* Updated: 2023/02/07 00:38:48 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
unsigned long long ft_factor(unsigned long long n)
{
unsigned long long r;
r = 1;
if (!(n >= 1 && n <= 20))
return (0);
if (n > 1)
r = n * ft_factor(n - 1);
return (r);
}

34
libft/src/ft_fczero.c Normal file
View File

@ -0,0 +1,34 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_fczero.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/02 04:29:09 by djonker #+# #+# */
/* Updated: 2023/02/07 00:38:49 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_fczero(long double n)
{
long double f;
long long i;
int l;
l = 0;
i = n;
f = n - i;
f = f * 10;
while (f < 1)
{
l++;
n = n * 10;
i = n;
f = n - i;
f = f * 10;
}
return (l);
}

23
libft/src/ft_flolen.c Normal file
View File

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_flolen.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/02 04:00:01 by djonker #+# #+# */
/* Updated: 2023/02/07 00:38:50 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_flolen(double n)
{
int l;
l = 1;
l = l + ft_declen(n);
l = l + ft_intlen(n);
return (l);
}

24
libft/src/ft_fnprim.c Normal file
View File

@ -0,0 +1,24 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_fnprim.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/01 04:42:24 by djonker #+# #+# */
/* Updated: 2023/02/07 00:38:50 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
unsigned long long ft_fnprim(unsigned long long n)
{
while (n < 1000000000000000000)
{
if (ft_isprim(n) == 1)
return (n);
n++;
}
return (0);
}

29
libft/src/ft_frearr.c Normal file
View File

@ -0,0 +1,29 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_frearr.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/12/11 21:54:13 by djonker #+# #+# */
/* Updated: 2023/02/07 00:39:42 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
void *ft_frearr(char **s)
{
int n;
n = 0;
while (s[n] != NULL)
n++;
while (n >= 0)
{
free(s[n]);
n--;
}
free(s);
return (NULL);
}

24
libft/src/ft_frenarr.c Normal file
View File

@ -0,0 +1,24 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_frenarr.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/12/11 21:54:13 by djonker #+# #+# */
/* Updated: 2023/02/07 00:39:47 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
void *ft_frenarr(char **s, int n)
{
while (n > 0)
{
n--;
free(s[n]);
}
free(s);
return (NULL);
}

41
libft/src/ft_fround.c Normal file
View File

@ -0,0 +1,41 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_fround.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/02 07:42:16 by djonker #+# #+# */
/* Updated: 2023/02/07 00:39:49 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
double ft_fround(double n, int h)
{
char *s;
char **t;
char *r;
s = ft_ftoa(n);
t = ft_split(s, '.');
t[0][ft_intlen(n)] = '.';
t[0][ft_intlen(n) + 1] = '\0';
if (h == 0)
{
if (t[1][0] > '5')
t[0][ft_intlen(n) - 1] = t[0][ft_intlen(n) - 1] + 1;
}
else if (t[1][h] > '5')
{
t[1][h - 1] = t[1][h - 1] + 1;
}
t[1][h] = '\0';
r = ft_strjoin(t[0], t[1]);
n = ft_atof(r);
ft_frenarr(t, 2);
free(r);
free(s);
return (n);
}

31
libft/src/ft_ftoa.c Normal file
View File

@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_ftoa.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/02 03:46:17 by djonker #+# #+# */
/* Updated: 2023/02/07 00:39:49 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
char *ft_ftoa(double n)
{
char *ti;
char *tf;
int i;
char *r;
ti = ft_itoa(n);
i = ft_ftoi(n);
r = ft_itoa(i);
tf = ft_strjoin(".", r);
free(r);
r = ft_strjoin(ti, tf);
free(ti);
free(tf);
return (r);
}

33
libft/src/ft_ftoi.c Normal file
View File

@ -0,0 +1,33 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_ftoi.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/02 21:30:30 by djonker #+# #+# */
/* Updated: 2023/02/07 00:39:50 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_ftoi(double n)
{
int r;
int l;
double f;
if (ft_isneg(n))
n = n * -1;
l = ft_declen(n);
r = n;
f = n - r;
while (l > 0)
{
f = f * 10;
l--;
}
r = f;
return (r);
}

36
libft/src/ft_getpwd.c Normal file
View File

@ -0,0 +1,36 @@
/* ************************************************************************** */
/* */
/* .--. _ */
/* ft_getpwd.c |o_o || | */
/* |:_/ || |_ _ ___ __ */
/* By: houtworm <codam@houtworm.net> // \ \ __| | | \ \/ / */
/* (| | )|_| |_| |> < */
/* Created: 2023/02/17 02:40:22 by houtworm /'\_ _/`\__|\__,_/_/\_\ */
/* Updated: 2023/02/17 02:55:28 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
char *ft_getpwd(char **envp, int slash)
{
char *pwd;
char *temp;
int i;
i = -1;
while (envp[++i])
if (ft_strncmp(envp[i], "PWD=", 4) == 0)
break ;
if (!envp[i])
return (NULL);
temp = ft_substr(envp[i], 4, ft_strlen(envp[i]));
if (!temp)
return (NULL);
if (slash)
pwd = ft_strjoin(temp, "/");
else
pwd = ft_strjoin(temp, NULL);
free(temp);
return (pwd);
}

24
libft/src/ft_htod.c Normal file
View File

@ -0,0 +1,24 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_htod.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/01/31 03:18:45 by djonker #+# #+# */
/* Updated: 2023/02/07 00:39:51 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
char ft_htod(long long n)
{
char r;
if (n > 9)
r = n + 87;
else
r = n + '0';
return (r);
}

34
libft/src/ft_htoi.c Normal file
View File

@ -0,0 +1,34 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_htoi.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/01/31 01:24:28 by djonker #+# #+# */
/* Updated: 2023/02/07 00:39:52 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_htoi(char *str)
{
int r;
int p;
r = 0;
p = ft_strlen(str) - 1;
while (p >= 0)
{
if (*str >= '0' && *str <= '9')
r = r + (*str - '0') * ft_power(16, p);
else if ((*str >= 'a' && *str <= 'f') || (*str >= 'A' && *str <= 'F'))
r = r + ft_dtoh(*str) * ft_power(16, p);
else
return (-0);
str++;
p--;
}
return (r);
}

22
libft/src/ft_iftof.c Normal file
View File

@ -0,0 +1,22 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_iftof.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/02 22:27:51 by djonker #+# #+# */
/* Updated: 2023/02/07 00:39:52 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
double ft_iftof(int i, int f)
{
double r;
r = 0;
r = r + i + ft_itof(f);
return (r);
}

30
libft/src/ft_intlen.c Normal file
View File

@ -0,0 +1,30 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_intlen.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/13 02:04:46 by djonker #+# #+# */
/* Updated: 2023/02/07 00:39:54 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_intlen(long long n)
{
int l;
l = 0;
if (n == 0)
return (1);
if (n <= 0)
l++;
while (n != 0)
{
n = n / 10 + (l * 0);
l++;
}
return (l);
}

22
libft/src/ft_isallbyte.c Normal file
View File

@ -0,0 +1,22 @@
/* ************************************************************************** */
/* */
/* .--. _ */
/* ft_isallbyte.c |o_o || | */
/* |:_/ || |_ _ ___ __ */
/* By: houtworm <codam@houtworm.net> // \ \ __| | | \ \/ / */
/* (| | )|_| |_| |> < */
/* Created: 2023/02/21 01:43:42 by houtworm /'\_ _/`\__|\__,_/_/\_\ */
/* Updated: 2023/02/21 01:43:44 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_isallbyte(char *str, char byte)
{
while (*str == byte)
str++;
if (!*str)
return (1);
return (0);
}

20
libft/src/ft_isalnum.c Normal file
View File

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_isalnum.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/11 15:56:37 by djonker #+# #+# */
/* Updated: 2023/02/07 00:39:54 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_isalnum(int c)
{
if ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && (c < '0' || c > '9'))
return (0);
return (1);
}

20
libft/src/ft_isalpha.c Normal file
View File

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_isalpha.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/01 19:10:41 by djonker #+# #+# */
/* Updated: 2023/02/07 00:39:55 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_isalpha(int c)
{
if ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z'))
return (0);
return (1);
}

20
libft/src/ft_isascii.c Normal file
View File

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_isascii.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/01 19:10:41 by djonker #+# #+# */
/* Updated: 2023/02/07 00:39:56 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_isascii(int c)
{
if (c < 0 || c > 127)
return (0);
return (1);
}

20
libft/src/ft_isdigit.c Normal file
View File

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_isdigit.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/01 19:10:41 by djonker #+# #+# */
/* Updated: 2023/02/07 00:39:56 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_isdigit(int c)
{
if (c < '0' || c > '9')
return (0);
return (1);
}

20
libft/src/ft_islneg.c Normal file
View File

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_islneg.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: houtworm <codam@houtworm.net> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/25 11:39:27 by houtworm #+# #+# */
/* Updated: 2023/02/07 00:39:57 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_islneg(long long n)
{
if (n < 0)
return (1);
return (0);
}

20
libft/src/ft_islowc.c Normal file
View File

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_islowc.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/04/13 17:57:31 by djonker #+# #+# */
/* Updated: 2023/02/07 00:39:58 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_islowc(char c)
{
if (c >= 'a' && c <= 'z')
return (1);
return (0);
}

20
libft/src/ft_isneg.c Normal file
View File

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_isneg.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/02 03:38:29 by djonker #+# #+# */
/* Updated: 2023/02/07 00:39:59 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_isneg(double n)
{
if (n < 0)
return (1);
return (0);
}

32
libft/src/ft_isodigit.c Normal file
View File

@ -0,0 +1,32 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_isodigit.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/06 17:19:46 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:00 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_isodigit(int n)
{
char *s;
s = ft_itoa(n);
while (*s != '\0')
{
if (*s >= '0' && *s <= '7')
s++;
else
{
free(s);
return (0);
}
}
free(s);
return (1);
}

35
libft/src/ft_isprim.c Normal file
View File

@ -0,0 +1,35 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_isprim.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/01 04:32:30 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:00 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_isprim(unsigned long long n)
{
unsigned long long c;
unsigned long long d;
if (n < 2)
return (0);
c = 2;
while (c <= n / 2)
{
d = 1;
while (d <= n / 2)
{
if (c * d == n)
return (0);
d++;
}
c++;
}
return (1);
}

20
libft/src/ft_isprint.c Normal file
View File

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_isprint.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/01 19:10:41 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:01 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_isprint(int c)
{
if (c < 32 || c > 126)
return (0);
return (1);
}

20
libft/src/ft_isuppc.c Normal file
View File

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_isuppc.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/04/13 17:57:31 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:02 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_isuppc(char c)
{
if (c >= 'A' && c <= 'Z')
return (1);
return (0);
}

27
libft/src/ft_isxdigit.c Normal file
View File

@ -0,0 +1,27 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_isxdigit.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/06 17:19:46 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:03 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_isxdigit(char *str)
{
while (*str != '\0')
{
if ((*str >= 'a' && *str <= 'f') || (*str >= 'A' && *str <= 'F'))
str++;
else if (*str >= '0' && *str <= '9')
str++;
else
return (0);
}
return (1);
}

42
libft/src/ft_itoa.c Normal file
View File

@ -0,0 +1,42 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_itoa.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/12 23:20:24 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:04 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
char *ft_itoa(int n)
{
char *r;
int l;
l = ft_intlen(n) - 1;
r = ft_calloc(l + 2, 1);
if (r == NULL)
return (NULL);
while ((n > 9 || n < 0) && n != -2147483648)
{
if (n >= 10)
{
r[l] = n % 10 + '0';
l--;
n = (n / 10);
}
else
{
r[0] = '-';
n = (n * -1);
}
}
r[l] = n + '0';
if (n == -2147483648)
ft_strlcpy(r, "-2147483648", 12);
return (r);
}

33
libft/src/ft_itob.c Normal file
View File

@ -0,0 +1,33 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_itob.c |o_o || | */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/01/04 04:42:54 by djonker #+# #+# */
/* Updated: 2023/03/07 05:07:51 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_itob(int d)
{
char s[20];
int i;
char *r;
i = 0;
while (d != 0)
{
s[i] = d % 2 + '0';
d = d / 2;
i++;
}
s[i] = '\0';
r = ft_revstr(s);
i = ft_atoi(r);
free(r);
return (i);
}

40
libft/src/ft_itoba.c Normal file
View File

@ -0,0 +1,40 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_itoba.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/01/04 04:42:54 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:05 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
char *ft_itoba(unsigned long long d, size_t e)
{
char s[65];
int i;
size_t j;
char *r;
i = 0;
while (d != 0)
{
s[i] = d % 2 + '0';
d = d / 2;
i++;
}
s[i] = '\0';
j = ft_strlen(s);
while (e > j)
{
s[i] = '0';
i++;
j++;
}
s[i] = '\0';
r = ft_revstr(s);
return (r);
}

42
libft/src/ft_itodd.c Normal file
View File

@ -0,0 +1,42 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_itodd.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/01/31 03:00:29 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:07 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
char *ft_itodd(double n)
{
char r[20];
int c;
double tf;
int ti;
char *s;
c = 0;
while (n != 0)
{
if (n < 12)
r[c] = ft_htod(n);
else if (n > 11)
{
tf = n / 12;
ti = n / 12;
tf = (tf - ti) * 12;
r[c] = ft_htod(tf);
}
ti = n / 12;
n = ti;
c++;
}
r[c] = '\0';
s = ft_revstr(r);
return (s);
}

28
libft/src/ft_itof.c Normal file
View File

@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_itof.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/02 22:18:50 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:07 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
double ft_itof(int n)
{
double r;
int l;
l = ft_intlen(n);
r = n;
while (l > 0)
{
r = r / 10;
l--;
}
return (r);
}

42
libft/src/ft_itoh.c Normal file
View File

@ -0,0 +1,42 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_itoh.c |o_o || | */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/01/31 03:00:29 by djonker #+# #+# */
/* Updated: 2023/03/05 20:33:06 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
char *ft_itoh(long double n)
{
char r[30];
int c;
long double tf;
long long ti;
char *s;
c = 0;
while (n != 0)
{
if (n < 16)
r[c] = ft_htod(n);
else if (n > 15)
{
tf = n / 16;
ti = n / 16;
tf = (tf - ti) * 16;
r[c] = ft_htod(tf);
}
ti = n / 16;
n = ti;
c++;
}
r[c] = '\0';
s = ft_revstr(r);
return (s);
}

42
libft/src/ft_itohx.c Normal file
View File

@ -0,0 +1,42 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_itohx.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/01/31 03:00:29 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:09 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
char *ft_itohx(long double n)
{
char r[30];
long int c;
long double tf;
long int ti;
char *s;
c = 0;
while (n != 0)
{
if (n < 16)
r[c] = ft_htod(n);
else if (n > 15)
{
tf = n / 16;
ti = n / 16;
tf = (tf - ti) * 16;
r[c] = ft_htod(tf);
}
ti = n / 16;
n = ti;
c++;
}
r[c] = '\0';
s = ft_revstr(r);
return (s);
}

41
libft/src/ft_itoo.c Normal file
View File

@ -0,0 +1,41 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_itoo.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/01 01:30:17 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:25 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
unsigned long long ft_itoo(double n)
{
char r[20];
unsigned long long c;
double tf;
unsigned long long ti;
c = 0;
while (n != 0)
{
if (n < 8)
r[c] = n + '0';
else if (n > 7)
{
tf = n / 8;
ti = n / 8;
tf = (tf - ti) * 8;
r[c] = tf + '0';
}
ti = n / 8;
n = ti;
c++;
}
r[c] = '\0';
c = ft_atou(ft_revstr(r));
return (c);
}

42
libft/src/ft_itooa.c Normal file
View File

@ -0,0 +1,42 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_itooa.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/01 01:30:17 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:25 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
char *ft_itooa(long double n)
{
char t[25];
char *r;
unsigned long long c;
long double tf;
unsigned long long ti;
c = 0;
while (n != 0)
{
if (n < 8)
t[c] = n + '0';
else if (n > 7)
{
tf = n / 8;
ti = n / 8;
tf = (tf - ti) * 8;
t[c] = tf + '0';
}
ti = n / 8;
n = ti;
c++;
}
t[c] = '\0';
r = ft_revstr(t);
return (r);
}

42
libft/src/ft_itozh.c Normal file
View File

@ -0,0 +1,42 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_itozh.c |o_o || | */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/01/31 03:00:29 by djonker #+# #+# */
/* Updated: 2023/03/07 05:15:26 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
char *ft_itozh(double n, int z)
{
char *s;
int l;
int i;
char *r;
r = ft_calloc(z + 1, 1);
i = 0;
s = ft_itoh(n);
l = ft_strlen(s);
while (l < z)
{
r[i] = '0';
l++;
i++;
}
l = 0;
while (l < z)
{
r[i] = s[l];
i++;
l++;
}
ft_strlcpy(s, (const char *)r, (size_t)z + 1);
free (r);
return (s);
}

32
libft/src/ft_ldeclen.c Normal file
View File

@ -0,0 +1,32 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_ldeclen.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: houtworm <codam@houtworm.net> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/25 11:30:37 by houtworm #+# #+# */
/* Updated: 2023/02/07 00:40:29 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_ldeclen(long double n)
{
long double f;
long long i;
int l;
i = n;
f = n - i;
l = 0;
while (f != 0 && l < 50)
{
l++;
n = n * 10;
i = n;
f = n - i;
}
return (l);
}

50
libft/src/ft_lftoa.c Normal file
View File

@ -0,0 +1,50 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lftoa.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: houtworm <codam@houtworm.net> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/25 11:38:35 by houtworm #+# #+# */
/* Updated: 2023/02/07 00:40:29 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
void *ft_memsetfrom(void *s, int c, size_t n, int from)
{
char *p;
p = s;
while (from > 0 && *p)
{
p++;
from--;
}
while (n > 0 && *p)
{
*p = c;
p++;
n--;
}
return (s);
}
char *ft_lftoa(long double n)
{
char *ti;
char *tf;
char *rr;
int i;
rr = ft_ltoa(n);
ti = ft_strjoin(rr, ".");
free(rr);
tf = ft_dtoa(n);
rr = ft_strjoin(ti, tf);
free(ti);
free(tf);
ft_memsetfrom(rr, '\0', ft_strlen(rr), 23);
return (rr);
}

33
libft/src/ft_lftoi.c Normal file
View File

@ -0,0 +1,33 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_lftoi.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: houtworm <codam@houtworm.net> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/25 11:30:20 by houtworm #+# #+# */
/* Updated: 2023/02/07 00:40:29 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
long long ft_lftoi(long double n)
{
long long r;
long long l;
long double f;
if (ft_islneg(n))
n = n * -1;
l = ft_ldeclen(n);
r = n;
f = n - r;
while (l > 0 && f * 10 < 9223372036854775807)
{
f = f * 10;
l--;
}
r = f;
return (r);
}

34
libft/src/ft_lincpy.c Normal file
View File

@ -0,0 +1,34 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_lincpy.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/04 21:40:35 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:29 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
void *ft_lincpy(char *dst, const char *src)
{
char *d;
const char *s;
long unsigned int i;
i = 0;
d = dst;
s = src;
if (dst != NULL || src != NULL)
{
while (s[i] != '\0' && s[i] != '\n')
{
d[i] = s[i];
i++;
}
d[i] = '\0';
}
return (dst);
}

35
libft/src/ft_linlcpy.c Normal file
View File

@ -0,0 +1,35 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_linlcpy.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/04 21:40:35 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:30 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
void *ft_linlcpy(char *dst, const char *src, size_t n)
{
char *d;
const char *s;
long unsigned int i;
i = 0;
d = dst;
s = src;
if (dst != NULL || src != NULL)
{
while (s[i] != '\0' && s[i] != '\n' && n > 0)
{
d[i] = s[i];
i++;
n--;
}
d[i] = '\0';
}
return (dst);
}

26
libft/src/ft_linlen.c Normal file
View File

@ -0,0 +1,26 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_linlen.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/04 15:49:15 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:30 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_linlen(char *str)
{
int l;
l = 0;
while (*str != '\0' && *str != '\n')
{
l++;
str++;
}
return (l);
}

29
libft/src/ft_lstadd_back.c Normal file
View File

@ -0,0 +1,29 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_lstadd_back.c |o_o || | */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/13 18:48:54 by djonker #+# #+# */
/* Updated: 2023/03/03 19:09:28 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
void ft_lstadd_back(t_list **lst, t_list *new)
{
t_list *l;
if (lst && new)
{
if (*lst)
{
l = ft_lstlast(*lst);
l->next = new;
}
else
*lst = new;
}
}

23
libft/src/ft_lstadd_front.c Normal file
View File

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_lstadd_front.c |o_o || | */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/13 04:38:37 by djonker #+# #+# */
/* Updated: 2023/03/03 16:12:15 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
void ft_lstadd_front(t_list **lst, t_list *new)
{
if (lst && new)
{
if (*lst)
new->next = *lst;
*lst = new;
}
}

29
libft/src/ft_lstclear.c Normal file
View File

@ -0,0 +1,29 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_lstclear.c |o_o || | */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/13 19:12:41 by djonker #+# #+# */
/* Updated: 2023/03/04 01:50:59 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
void ft_lstclear(t_list **lst, void (*del)(void*))
{
t_list *t;
t = NULL;
if (lst)
{
while (*lst)
{
t = (*lst)->next;
ft_lstdelone(*lst, del);
*lst = t;
}
}
}

27
libft/src/ft_lstdelone.c Normal file
View File

@ -0,0 +1,27 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_lstdelone.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/13 19:06:46 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:31 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
void ft_lstdelone(t_list *lst, void (*del)(void*))
{
if (!del)
{
free (lst);
return ;
}
if (lst)
{
(*del)(lst->content);
free(lst);
}
}

24
libft/src/ft_lstiter.c Normal file
View File

@ -0,0 +1,24 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_lstiter.c |o_o || | */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/13 19:15:47 by djonker #+# #+# */
/* Updated: 2023/03/04 15:30:35 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
void ft_lstiter(t_list *lst, void (*f)(void *))
{
if (!f || lst == NULL)
return ;
while (lst)
{
(*f)(lst->content);
lst = lst->next;
}
}

24
libft/src/ft_lstlast.c Normal file
View File

@ -0,0 +1,24 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_lstlast.c |o_o || | */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/13 18:45:02 by djonker #+# #+# */
/* Updated: 2023/03/03 18:08:43 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
t_list *ft_lstlast(t_list *lst)
{
while (lst)
{
if (!lst->next)
return (lst);
lst = lst->next;
}
return (lst);
}

40
libft/src/ft_lstmap.c Normal file
View File

@ -0,0 +1,40 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_lstmap.c |o_o || | */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/13 19:30:13 by djonker #+# #+# */
/* Updated: 2023/03/04 16:07:56 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
t_list *ft_lstmap(t_list *lst, void *(*f)(void *), void (*del)(void *))
{
void *s;
t_list *r;
t_list *t;
r = NULL;
t = NULL;
while (lst && f)
{
if (f(lst->content))
{
s = f(lst->content);
t = ft_lstnew(s);
if (!(t))
{
ft_lstclear(&r, del);
lst = NULL;
return (NULL);
}
ft_lstadd_back(&r, t);
}
lst = lst->next;
}
return (r);
}

25
libft/src/ft_lstnew.c Normal file
View File

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_lstnew.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/13 04:38:37 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:35 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
t_list *ft_lstnew(void *content)
{
t_list *r;
r = malloc(sizeof(t_list));
if (r == NULL)
return (NULL);
r->content = content;
r->next = NULL;
return (r);
}

26
libft/src/ft_lstsize.c Normal file
View File

@ -0,0 +1,26 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_lstsize.c |o_o || | */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/13 18:27:52 by djonker #+# #+# */
/* Updated: 2023/03/03 17:20:28 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_lstsize(t_list *lst)
{
size_t i;
i = 0;
while (lst)
{
lst = lst->next;
i++;
}
return (i);
}

42
libft/src/ft_ltoa.c Normal file
View File

@ -0,0 +1,42 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_ltoa.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/12 23:20:24 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:35 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
char *ft_ltoa(long long n)
{
char *r;
int l;
l = ft_intlen(n) - 1;
r = ft_calloc(l + 2, 1);
if (r == NULL)
return (NULL);
while ((n > 9 || n < 0) && n >= -9223372036854775807)
{
if (n >= 10)
{
r[l] = n % 10 + '0';
l--;
n = (n / 10);
}
else
{
r[0] = '-';
n = (n * -1);
}
}
r[l] = n + '0';
if (n < -9223372036854775807)
ft_strlcpy(r, "-9223372036854775808", 20);
return (r);
}

28
libft/src/ft_luilen.c Normal file
View File

@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_luilen.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/13 02:04:46 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:35 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_luilen(unsigned long long n)
{
int l;
l = 0;
if (n == 0)
return (1);
while (n != 0)
{
n = n / 10 + (l * 0);
l++;
}
return (l);
}

31
libft/src/ft_malstr.c Normal file
View File

@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_malstr.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/29 15:21:11 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:36 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
char *ft_malstr(char *s, char c)
{
char *r;
int l;
r = ft_calloc(ft_wrdlen((char *)s, c, 0) + 1, 1);
if (!r)
return (NULL);
l = 0;
while (*s != '\0' && *s != c)
{
r[l] = *s;
l++;
s++;
}
return (r);
}

31
libft/src/ft_malstrs.c Normal file
View File

@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_malstrs.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/29 15:21:11 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:36 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
char *ft_malstrs(char *s, char *c)
{
char *r;
int l;
r = ft_calloc(ft_wrdlens((char *)s, c, 0) + 1, 1);
if (!r)
return (NULL);
l = 0;
while (*s != '\0' && !(ft_chrstr(*s, c)))
{
r[l] = *s;
l++;
s++;
}
return (r);
}

20
libft/src/ft_max.c Normal file
View File

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_max.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/08 04:26:11 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:36 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_max(int a, int b)
{
if (a > b)
return (a);
return (b);
}

38
libft/src/ft_memccpy.c Normal file
View File

@ -0,0 +1,38 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_memccpy.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/01 08:38:54 by djonker #+# #+# */
/* Updated: 2023/02/24 20:52:37 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
void *ft_memccpy(void *dst, const void *src, int c, size_t n)
{
unsigned char *d;
unsigned const char *s;
unsigned char u;
if (!dst || !src)
return (NULL);
if (u > ft_strlen(dst))
u = ft_strlen(dst);
d = dst;
s = src;
u = c;
while (n != 0)
{
*d = *s;
if (*d == u)
return (d + 1);
n--;
d++;
s++;
}
return (NULL);
}

32
libft/src/ft_memchr.c Normal file
View File

@ -0,0 +1,32 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_memchr.c |o_o || | */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/01 08:35:56 by djonker #+# #+# */
/* Updated: 2023/02/27 05:12:02 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
void *ft_memchr(const void *s, int c, size_t n)
{
unsigned char *p;
unsigned char t;
if (!s)
return (NULL);
t = (unsigned char)c;
p = (unsigned char *)s;
while (n > 0)
{
if (t == *p)
return ((void *)p);
n--;
++p;
}
return (NULL);
}

35
libft/src/ft_memcmp.c Normal file
View File

@ -0,0 +1,35 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_memcmp.c |o_o || | */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/01 08:41:32 by djonker #+# #+# */
/* Updated: 2023/02/28 15:22:59 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_memcmp(const void *s1, const void *s2, size_t n)
{
const unsigned char *p1;
const unsigned char *p2;
if (!s1 && !s2)
return (0);
if (!s1 || !s2)
return (1);
p1 = s1;
p2 = s2;
while (n)
{
if (*p1 != *p2)
return (*p1 - *p2);
p1++;
p2++;
n--;
}
return (0);
}

37
libft/src/ft_memcpy.c Normal file
View File

@ -0,0 +1,37 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_memcpy.c |o_o || | */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/11 16:13:52 by djonker #+# #+# */
/* Updated: 2023/03/01 18:06:11 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
void *ft_memcpy(void *dst, const void *src, size_t n)
{
char *d;
const char *s;
long unsigned int i;
if (!dst)
return (dst);
d = dst;
if (!src)
{
*d = '\0';
return (dst);
}
s = src;
i = 0;
while (n > i)
{
d[i] = s[i];
i++;
}
return (dst);
}

41
libft/src/ft_memmove.c Normal file
View File

@ -0,0 +1,41 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_memmove.c |o_o || | */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/01 08:45:04 by djonker #+# #+# */
/* Updated: 2023/03/03 12:19:05 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
void *ft_memmove(void *dst, const void *src, size_t len)
{
char *d;
const char *s;
int i;
if (dst == NULL || src == NULL)
return ((void *)dst);
i = 0;
d = dst;
s = src;
if (d >= s)
{
s = s + (len - 1);
d = d + (len - 1);
}
while (len)
{
len--;
d[i] = s[i];
if (d < s)
i++;
else
i--;
}
return (dst);
}

29
libft/src/ft_memset.c Normal file
View File

@ -0,0 +1,29 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_memset.c |o_o || | */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/01 08:42:45 by djonker #+# #+# */
/* Updated: 2023/02/28 20:13:47 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
void *ft_memset(void *s, int c, size_t n)
{
char *p;
if (!s)
return (s);
p = s;
while (n > 0)
{
*p = c;
p++;
n--;
}
return (s);
}

20
libft/src/ft_min.c Normal file
View File

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_min.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/08 04:26:11 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:40 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_min(int a, int b)
{
if (a < b)
return (a);
return (b);
}

34
libft/src/ft_otoi.c Normal file
View File

@ -0,0 +1,34 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_otoi.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/01/31 16:54:01 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:40 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_otoi(int i)
{
char *s;
int is;
int ir;
int r;
is = ft_intlen(i) - 1;
ir = 0;
r = 0;
s = ft_itoa(i);
while (s[is] != '\0')
{
r = r + (s[is] - '0') * ft_power(8, ir);
is--;
ir++;
}
free(s);
return (r);
}

26
libft/src/ft_power.c Normal file
View File

@ -0,0 +1,26 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_power.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/01/31 01:18:37 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:40 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
int ft_power(int n, int p)
{
int r;
if (p < 0)
return (0);
if (p == 0)
return (1);
else
r = n * ft_power(n, p - 1);
return (r);
}

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

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_putchar.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/13 03:47:51 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:40 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
void ft_putchar(char c)
{
write(1, &c, sizeof(c));
}

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

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_putchar_fd.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/13 03:47:51 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:42 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
void ft_putchar_fd(char c, int fd)
{
write(fd, &c, sizeof(c));
}

25
libft/src/ft_putendl.c Normal file
View File

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_putendl.c |o_o || | */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/13 04:00:47 by djonker #+# #+# */
/* Updated: 2023/02/23 20:14:17 by houtworm \___)=(___/ */
/* */
/* ************************************************************************** */
#include "../libft.h"
void ft_putendl(char *s)
{
if (!s)
return ((void) NULL);
while (*s)
{
write(1, s, 1);
s++;
}
write(1, "\n", 1);
}

25
libft/src/ft_putendl_fd.c Normal file
View File

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_putendl_fd.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/13 04:00:47 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:43 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
void ft_putendl_fd(char *s, int fd)
{
if (!s)
return ((void) NULL);
while (*s)
{
write(fd, s, 1);
s++;
}
write(fd, "\n", 1);
}

25
libft/src/ft_putflo.c Normal file
View File

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_putflo.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/02 21:45:39 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:43 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
void ft_putflo(double n)
{
int i;
int f;
i = n;
f = ft_ftoi(n);
ft_putnbr(i);
ft_putchar('.');
ft_putnbr(f);
}

25
libft/src/ft_putflo_fd.c Normal file
View File

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_putflo_fd.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2021/02/02 21:45:39 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:43 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
void ft_putflo_fd(double n, int fd)
{
int i;
int f;
i = n;
f = ft_ftoi(n);
ft_putnbr_fd(i, fd);
ft_putchar_fd('.', fd);
ft_putnbr_fd(f, fd);
}

31
libft/src/ft_putlong.c Normal file
View File

@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_putlong.c :+: :+: :+: */
/* +:+ */
/* By: djonker <marvin@codam.nl> +#+ */
/* +#+ */
/* Created: 2020/11/13 04:22:10 by djonker #+# #+# */
/* Updated: 2023/02/07 00:40:43 by houtworm ### ########.fr */
/* */
/* ************************************************************************** */
#include "../libft.h"
void ft_putlong(long long n)
{
if (n < -9223372036854775807)
return (ft_putstr("-9223372036854775808"));
if (n < 0)
{
ft_putchar('-');
n = n * -1;
}
if (n >= 10)
{
ft_putlong(n / 10);
ft_putlong(n % 10);
}
else
ft_putchar(n + '0');
}

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