Changing the lib

include/my.h

@@ -6,6 +6,8 @@
 */
 #pragma once
 
+int my_printf(const char *str, ...);
+
 int count_valid_queens_placements(int n);
 
 char *my_strchr(const char *str, char c);

lib/my/Makefile

@@ -1,30 +1,62 @@
 ##
 ## EPITECH PROJECT, 2019
-## Makefile
+## PSU_my_printf_bootstrap_2019
 ## File description:
-## Lib makefile
+## Makefile
 ##
 
-SRC = *.c
+SRC = src/printf.c \
+	src/printf_utility.c \
+	src/my_putlonglong_base.c \
+	src/formaters/string_formater.c \
+	src/formaters/string_nonprintable_formater.c \
+	src/formaters/char_formater.c \
+	src/formaters/int_formater.c \
+	src/formaters/uint_formater.c \
+	src/formaters/ptr_formater.c \
+	src/formaters/ubinary_formater.c \
+	src/formaters/octal_formater.c \
+	src/formaters/hexa_formater.c \
+	src/formaters/big_hexa_formater.c \
+	src/formaters/float_formater.c \
+	src/formaters/no_format.c \
+	src/get_nbr_size.c \
+	my/*.c
 
-OBJ = *.o \
-	*.gc*
+OBJ = *.o
 
-LIBOBJ = lib/my/*.o \
-	lib/my/libmy.a \
-	include/my.h
+TESTS = tests/test_printf.c
 
-all: buildlib
+INCLUDE = -I ./include
 
-buildlib:
-	gcc -c ./*.c
-	ar rc ./libmy.a ./*.o
+COVERAGE = --coverage -lcriterion
+
+CC = gcc
+
+CFLAGS = -Wall -Wshadow -Wextra -Wno-unused-parameter
+
+NAME = libmy.a
+
+UT = ut
+
+all: build
+
+build:
+	$(CC) -c $(SRC) $(INCLUDE) $(CFLAGS)
+	ar rc $(NAME) $(OBJ)
+
+tests_run:
+	$(CC) -o $(UT) $(SRC) $(TESTS) $(INCLUDE) $(COVERAGE) $(CFLAGS)
+	./$(UT)
 
 clean:
-	rm -f $(OBJ)
+	rm -rf $(OBJ)
+	rm -rf *.gc*
 
-fclean:
-	rm -f $(LIBOBJ)
-	rm -f libmy.a
+fclean: clean
+	rm -rf $(NAME)
+	rm -rf $(UT)
 
 re: fclean all
+
+.PHONY = all build clean fclean

lib/my/include/formaters.h

@@ -0,0 +1,37 @@
+/*
+** EPITECH PROJECT, 2019
+** Formater struct
+** File description:
+** formaters
+*/
+
+#pragma once
+#include <stdarg.h>
+
+#define MODIFIERS_SIZE 50
+
+typedef struct formater
+{
+    int (*func)(va_list ap, char modifiers[MODIFIERS_SIZE]);
+    char flag;
+} formater_t;
+
+int string_formater(va_list ap, char modifiers[MODIFIERS_SIZE]);
+int string_nonprintable_formater(va_list ap, char modifiers[MODIFIERS_SIZE]);
+int char_formater(va_list ap, char modifiers[MODIFIERS_SIZE]);
+int int_formater(va_list ap, char modifiers[MODIFIERS_SIZE]);
+int uint_formater(va_list ap, char modifiers[MODIFIERS_SIZE]);
+int ptr_formater(va_list ap, char modifiers[MODIFIERS_SIZE]);
+int ubinary_formater(va_list ap, char modifiers[MODIFIERS_SIZE]);
+int octal_formater(va_list ap, char modifiers[MODIFIERS_SIZE]);
+int hexa_formater(va_list ap, char modifiers[MODIFIERS_SIZE]);
+int big_hexa_formater(va_list ap, char modifiers[MODIFIERS_SIZE]);
+int float_formater(va_list ap, char modifiers[MODIFIERS_SIZE]);
+int no_format(va_list ap, char modifiers[MODIFIERS_SIZE]);
+
+int count(char c, char *str);
+int contains(char c, char *str);
+int get_nbr_len(long long int n, const char *base);
+int is_modifier(char c);
+int last_mod(char *modifiers);
+int my_putlonglong_base(long long int nbr, const char *base, int length);

lib/my/include/my.h

@@ -6,9 +6,13 @@
 */
 #pragma once
 
-int count_valid_queens_placements(int n);
+int my_printf(const char *str, ...);
 
-char *my_strchr(const char *str, char c);
+void print_ptr(void *ptr);
+
+void print_str_to(char *ptr, int max);
+
+int count_valid_queens_placements(int n);
 
 int my_compute_power_it(int n, int p);
 
@@ -18,7 +22,7 @@ int my_compute_factorial_it(int n);
 
 int my_compute_factorial_rec(int n);
 
-int my_compute_square_root(int n);
+int my_sqrt(int nb);
 
 char *my_evil_str(char *str);
 
@@ -46,7 +50,7 @@ void my_print_revalpha(void);
 
 void my_putchar(char c);
 
-void my_putlong_base(long n, const char *base);
+int my_putlong_base(long long nbr, const char *base);
 
 void my_putnbr_base(int n, const char *base);
 
@@ -56,7 +60,7 @@ void my_putstr(const char *str);
 
 void my_revstr(char *str);
 
-void my_showmem(const char *str);
+int my_showmem(char *str, int size);
 
 void my_showstr(const char *str);
 
@@ -72,11 +76,11 @@ int is_digit(char c);
 
 char *my_strcapitalize(char *str);
 
-char *my_strcat(char *dest, const char *src);
+char *my_strcat(char *dest, const char *str);
 
 int my_strcmp(const char *s1, const char *s2);
 
-char *my_strcpy(const char *str);
+char *my_strcpy(char *dest, const char *src);
 
 int my_str_isalpha(const char *str);
 
@@ -96,7 +100,7 @@ int my_strlen(const char *str);
 
 int my_strlowcase(const char *str);
 
-char *my_strncat(char *dest, const char *src, int n);
+char *my_strncat(char *dest, const char *str, int n);
 
 int my_strncmp(const char *s1, const char *s2, int n);
 

lib/my/my/my_compute_power_it.c

@@ -5,7 +5,7 @@
 ** Power calculator
 */
 
-int my_compute_power_it(int nb, int p)
+int my_pow(int nb, int p)
 {
     int ret = 1;
     int mult = 1;

lib/my/my/my_compute_square_root.c

@@ -5,7 +5,7 @@
 ** Square root calculator
 */
 
-int my_compute_square_root(int nb)
+int my_sqrt(int nb)
 {
     if (nb < 0)
         return 0;

lib/my/my/my_getnbr.c

@@ -24,7 +24,7 @@ static int parse(const char *str, int digit_count, int neg)
         }
         n += add;
 
-        if ((neg == -1 && n > 0) || neg == 1 && n < 0)
+        if ((neg == -1 && n > 0) || (neg == 1 && n < 0))
             return 0;
     }
     return n;
@@ -57,7 +57,7 @@ int my_getnbr(const char *str)
 
     for (int i = 0; 1; i++) {
         c = str[i];
-        if (c >= '0' && c <= '9' || c == '-' || c == '+') {
+        if ((c >= '0' && c <= '9') || c == '-' || c == '+') {
             if (start_index == -1)
                 start_index = i;
             count++;

lib/my/my/my_showmem.c

@@ -0,0 +1,74 @@
+/*
+** EPITECH PROJECT, 2019
+** Memory dump
+** File description:
+** Debug Library
+*/
+
+const char *hex = "0123456789abcdef";
+
+#include "my.h"
+#include <unistd.h>
+
+int get_size(long n, const char *base);
+
+void my_putchar(char c);
+
+int is_printable(char c);
+
+void display_x_char(char c, int count)
+{
+    for (int i = 0; i < count; i++)
+        write(1, &c, 1);
+}
+
+void print_ptr(void *ptr)
+{
+    write(1, "0x", 2);
+    my_putlong_base((long)ptr, hex);
+}
+
+void print_hexa(char *ptr, int size)
+{
+    for (int i = 0; i < 16; i++) {
+        if (i >= size) {
+            display_x_char(' ', 40 - (i * 2 + i / 2));
+            return;
+        }
+        if (ptr[i] < 16)
+            my_putchar('0');
+        my_putlong_base((long)ptr[i], hex);
+        if (i % 2 == 1)
+            my_putchar(' ');
+    }
+}
+
+void print_str_to(char *ptr, int max)
+{
+    int overflow = 0;
+
+    for (int i = 0; i < max; i++) {
+        if (overflow || !is_printable(ptr[i]))
+            my_putchar('.');
+        else
+            my_putchar(ptr[i]);
+        if (!overflow)
+            overflow = ptr[i] == '\0';
+    }
+}
+
+int my_showmem(char *str, int size)
+{
+    int padding = size % 16;
+    int line_count = padding == 0 ? size / 16 : size / 16 + 1;
+    char *ptr;
+
+    for (int i = 0; i < line_count; i++) {
+        ptr = (str + i * 16);
+        print_ptr((void *)(ptr - str));
+        print_hexa(ptr, size - i * 16);
+        print_str_to(ptr, 16);
+        my_putchar('\n');
+    }
+    return (0);
+}

lib/my/my/my_showstr.c

@@ -11,20 +11,23 @@ int is_printable(char c);
 
 int my_putnbr_base(int i, const char *base);
 
-static void puthex(char c)
+void puthex(char c)
 {
-    char zero = '0';
+    write(1, "\\", 1);
+    if (c < 8)
+        write(1, "0", 1);
     if (c < 16)
-        write(1, &zero, 1);
-    my_putnbr_base(c, "0123456789ABCDEF");
+        write(1, "0", 1);
+    my_putnbr_base(c, "01234567");
 }
 
 int my_showstr(const char *str)
 {
-    for (int i = 0; str[i] != '\0'; i++) {
+    for (int i = 0; str[i]; i++) {
         if (is_printable(str[i]))
-            write(1, &str[i], 1);
+            write(1, &(str[i]), 1);
         else
             puthex(str[i]);
     }
+    return (0);
 }

lib/my/my/my_sort_int_array.c

@@ -5,7 +5,7 @@
 ** Int array sorter
 */
 
-static int sort_linear(int *array, int size)
+static void sort_linear(int *array, int size)
 {
     for (int i = 0; i < size - 1; i++) {
         if (array[i] > array[i + 1]) {
@@ -20,4 +20,5 @@ int my_sort_int_array(int *array, int size)
 {
     for (int i = 0; i < size; i++)
         sort_linear(array, size);
+    return (0);
 }

lib/my/my/my_str_to_word_array.c

@@ -14,7 +14,6 @@ int first_alphanum(const char *str);
 static int count_words(const char *str)
 {
     int count = 1;
-    int word_length = 0;
 
     if (first_alphanum(str) == -1)
         return (0);

lib/my/my/my_strlen.c

@@ -7,8 +7,6 @@
 
 int my_strlen(const char *str)
 {
-    if (str == 0)
-        return (0);
     for (int i = 0; 1; i++) {
         if (*(str + i) == '\0')
             return i;

lib/my/my/utility.c

@@ -0,0 +1,20 @@
+/*
+** EPITECH PROJECT, 2019
+** Utility for the showmem
+** File description:
+** utility
+*/
+
+#include "my.h"
+
+int get_size(long n, const char *base)
+{
+    int base_size = my_strlen(base);
+    int i = 1;
+
+    while (n >= base_size) {
+        n /= base_size;
+        i++;
+    }
+    return (i);
+}

lib/my/my_compte_power_it.c

@@ -1,29 +0,0 @@
-/*
-** EPITECH PROJECT, 2019
-** CPool_Day05_2019
-** File description:
-** Power calculator
-*/
-
-int my_compute_power_it(int nb, int p)
-{
-    int ret = 1;
-    int mult = 1;
-
-    if (p < 0)
-        return 0;
-    if (nb < 0) {
-        nb *= -1;
-        if (p % 2 == 1)
-            mult = -1;
-    }
-    while (p > 0) {
-        ret *= nb;
-        p--;
-
-        if (ret < 0)
-            return (0);
-    }
-
-    return (ret * mult);
-}

lib/my/my_compute_power_rec.c

@@ -1,31 +0,0 @@
-/*
-** EPITECH PROJECT, 2019
-** CPool_Day05_2019
-** File description:
-** Power calculator but in recursive mode
-*/
-
-static int calculate(int nb, int p, int ret)
-{
-    if (ret < 0)
-        return 0;
-
-    if (p == 0)
-        return ret;
-
-    return calculate(nb, p - 1, ret * nb);
-}
-
-int my_compute_power_rec(int nb, int p)
-{
-    int mult = 1;
-
-    if (p < 0)
-        return (0);
-    if (nb < 0) {
-        nb *= -1;
-        if (p % 2 == 1)
-            mult = -1;
-    }
-    return (calculate(nb, p, 1) * mult);
-}

lib/my/src/#printf.c#

@@ -0,0 +1,95 @@
+/*
+** EPITECH PROJECT, 2019
+** Sum stdarg
+** File description:
+** sum_stdarg
+*/
+
+#include "formaters.h"
+#include "my.h"
+#include <stdarg.h>
+#include <unistd.h>
+
+formater_t formaters[] = {{string_formater, 's'},
+			  {string_nonprintable_formater, 'S'},
+                          {char_formater, 'c'},
+                          {int_formater, 'i'},
+                          {int_formater, 'd'},
+                          {octal_formater, 'o'},
+                          {hexa_formater, 'x'},
+                          {big_hexa_formater, 'X'},
+                          {uint_formater, 'u'},
+                          {ptr_formater, 'p'},
+                          {ubinary_formater, 'b'},
+                          {float_formater, 'f'},
+                          {float_formater, 'F'},
+                          {no_format, '%'},
+                          {0, 0}};
+
+const char modifiersCst[] = "#0-+ hl";
+
+int format(va_list ap, char flag, char modifiers[MODIFIERS_SIZE])
+{
+    for (int i = 0; formaters[i].flag; i++) {
+        if (formaters[i].flag == flag) {
+            return (formaters[i].func(ap, modifiers));
+        }
+    }
+    return (0);
+}
+
+int is_flag(char c)
+{
+    for (int i = 0; formaters[i].flag; i++) {
+        if (formaters[i].flag == c) {
+            return (1);
+        }
+    }
+    return (0);
+}
+
+int is_modifier(char c)
+{
+    for (int i = 0; modifiersCst[i]; i++) {
+        if (modifiersCst[i] == c)
+            return (1);
+    }
+    return (0);
+}
+
+int get_modifiers(const char *str, char flags[MODIFIERS_SIZE])
+{
+    int i;
+
+    for (i = 0; !is_flag(str[i]); i++) {
+        if (!is_modifier(str[i]) && !is_num(str[i]))
+            return (-1);
+        flags[i] = str[i];
+    }
+    flags[i] = '\0';
+    return (i);
+}
+
+int my_printf(const char *str, ...)
+{
+    int count = 0;
+    va_list ap;
+    char modifiers[MODIFIERS_SIZE];
+    int next_is_flag;
+
+    va_start(ap, str);
+    for (int i = 0; str[i]; i++) {
+        if (str[i] == '%') {
+            next_is_flag = 1;
+            i++;
+            i += get_modifiers(&str[i], modifiers);
+        } else
+            next_is_flag = 0;
+        if (next_is_flag && is_flag(str[i]))
+            count += format(ap, str[i], modifiers);
+        else
+            count += write(1, &str[i], 1);
+    }
+    va_end(ap);
+    return (count);
+}

lib/my/src/formaters/big_hexa_formater.c

@@ -0,0 +1,31 @@
+/*
+** EPITECH PROJECT, 2019
+** int formater
+** File description:
+** int_formater
+*/
+
+#include "formaters.h"
+#include "my.h"
+#include <stdarg.h>
+#include <unistd.h>
+
+int big_hexa_formater(va_list ap, char mod[MODIFIERS_SIZE])
+{
+    long long int var;
+    int nbrlen;
+
+    if (count('l', mod) >= 2)
+        var = va_arg(ap, unsigned long long int);
+    else if (count('l', mod) == 1)
+        var = va_arg(ap, unsigned long);
+    else
+        var = va_arg(ap, unsigned int);
+    if (contains('0', mod))
+        nbrlen = my_getnbr(&mod[last_mod(mod)]);
+    else
+        nbrlen = 0;
+    if (var != 0 && contains('#', mod))
+        nbrlen -= write(1, "0X", 2);
+    return (my_putlonglong_base(var, "0123456789ABCDEF", nbrlen));
+}

lib/my/src/formaters/char_formater.c

@@ -0,0 +1,18 @@
+/*
+** EPITECH PROJECT, 2019
+** Char formater
+** File description:
+** char_formater
+*/
+
+#include "formaters.h"
+#include "my.h"
+#include <stdarg.h>
+#include <unistd.h>
+
+int char_formater(va_list ap, char mod[MODIFIERS_SIZE])
+{
+    char var = (char)va_arg(ap, int);
+
+    return (write(1, &var, 1));
+}

lib/my/src/formaters/float_formater.c

@@ -0,0 +1,24 @@
+/*
+** EPITECH PROJECT, 2019
+** int formater
+** File description:
+** int_formater
+*/
+
+#include "formaters.h"
+#include "my.h"
+#include <stdarg.h>
+#include <unistd.h>
+
+int float_formater(va_list ap, char mod[MODIFIERS_SIZE])
+{
+    double var = va_arg(ap, double);
+    int decimal = (var - (int)var) * 1000000 + 1;
+
+    while (decimal % 10 == 0)
+        decimal /= 10;
+    my_put_nbr((int)var);
+    write(1, ".", 1);
+    my_put_nbr(decimal);
+    return (0);
+}

lib/my/src/formaters/hexa_formater.c

@@ -0,0 +1,31 @@
+/*
+** EPITECH PROJECT, 2019
+** int formater
+** File description:
+** int_formater
+*/
+
+#include "formaters.h"
+#include "my.h"
+#include <stdarg.h>
+#include <unistd.h>
+
+int hexa_formater(va_list ap, char mod[MODIFIERS_SIZE])
+{
+    long long int var;
+    int nbrlen;
+
+    if (count('l', mod) >= 2)
+        var = va_arg(ap, unsigned long long int);
+    else if (count('l', mod) == 1)
+        var = va_arg(ap, unsigned long);
+    else
+        var = va_arg(ap, unsigned int);
+    if (contains('0', mod))
+        nbrlen = my_getnbr(&mod[last_mod(mod)]);
+    else
+        nbrlen = 0;
+    if (var != 0 && contains('#', mod))
+        nbrlen -= write(1, "0x", 2);
+    return (my_putlonglong_base(var, "0123456789abcdef", nbrlen));
+}

lib/my/src/formaters/int_formater.c

@@ -0,0 +1,33 @@
+/*
+** EPITECH PROJECT, 2019
+** int formater
+** File description:
+** int_formater
+*/
+
+#include "formaters.h"
+#include "my.h"
+#include <stdarg.h>
+#include <unistd.h>
+
+int int_formater(va_list ap, char mod[MODIFIERS_SIZE])
+{
+    long long int var;
+    int nbrlen;
+
+    if (count('l', mod) >= 2)
+        var = va_arg(ap, long long int);
+    else if (count('l', mod) == 1)
+        var = va_arg(ap, long);
+    else
+        var = va_arg(ap, int);
+    if (contains('0', mod))
+        nbrlen = my_getnbr(&mod[last_mod(mod)]);
+    else
+        nbrlen = 0;
+    if (var >= 0 && contains(' ', mod) && !contains('+', mod))
+        nbrlen -= write(1, " ", 1);
+    if (var >= 0 && contains('+', mod))
+        nbrlen -= write(1, "+", 1);
+    return (my_putlonglong_base(var, "0123456789", nbrlen));
+}

lib/my/src/formaters/no_format.c

@@ -0,0 +1,16 @@
+/*
+** EPITECH PROJECT, 2019
+** int formater
+** File description:
+** int_formater
+*/
+
+#include "formaters.h"
+#include "my.h"
+#include <stdarg.h>
+#include <unistd.h>
+
+int no_format(va_list _ap, char mod[MODIFIERS_SIZE])
+{
+    return (write(1, "%", 1));
+}

lib/my/src/formaters/octal_formater.c

@@ -0,0 +1,31 @@
+/*
+** EPITECH PROJECT, 2019
+** int formater
+** File description:
+** int_formater
+*/
+
+#include "formaters.h"
+#include "my.h"
+#include <stdarg.h>
+#include <unistd.h>
+
+int octal_formater(va_list ap, char mod[MODIFIERS_SIZE])
+{
+    long long int var;
+    int nbrlen;
+
+    if (count('l', mod) >= 2)
+        var = va_arg(ap, unsigned long long int);
+    else if (count('l', mod) == 1)
+        var = va_arg(ap, unsigned long);
+    else
+        var = va_arg(ap, unsigned int);
+    if (contains('0', mod))
+        nbrlen = my_getnbr(&mod[last_mod(mod)]);
+    else
+        nbrlen = 0;
+    if (var != 0 && contains('#', mod))
+        nbrlen -= write(1, "0", 2);
+    return (my_putlonglong_base(var, "01234567", nbrlen));
+}

lib/my/src/formaters/ptr_formater.c

@@ -0,0 +1,19 @@
+/*
+** EPITECH PROJECT, 2019
+** Char formater
+** File description:
+** char_formater
+*/
+
+#include "formaters.h"
+#include "my.h"
+#include <stdarg.h>
+#include <unistd.h>
+
+int ptr_formater(va_list ap, char mod[MODIFIERS_SIZE])
+{
+    void *var = va_arg(ap, void *);
+
+    print_ptr(var);
+    return (0);
+}

lib/my/src/formaters/string_formater.c

@@ -0,0 +1,23 @@
+/*
+** EPITECH PROJECT, 2019
+** String formater
+** File description:
+** string_formater
+*/
+
+#include <stdarg.h>
+#include <unistd.h>
+#include "formaters.h"
+#include "my.h"
+
+int string_formater(va_list ap, char mod[MODIFIERS_SIZE])
+{
+    char *var = va_arg(ap, char *);
+    int length;
+
+    if (contains('0', mod))
+        length = my_getnbr(&mod[last_mod(mod)]);
+    else
+        length = my_strlen(var);
+    return (write(1, var, length));
+}

lib/my/src/formaters/string_nonprintable_formater.c

@@ -0,0 +1,19 @@
+/*
+** EPITECH PROJECT, 2019
+** String formater
+** File description:
+** string_formater
+*/
+
+#include <stdarg.h>
+#include <unistd.h>
+#include "formaters.h"
+#include "my.h"
+
+int string_nonprintable_formater(va_list ap, char mod[MODIFIERS_SIZE])
+{
+    char *var = va_arg(ap, char *);
+
+    my_showstr(var);
+    return (0);
+}

lib/my/src/formaters/ubinary_formater.c

@@ -0,0 +1,29 @@
+/*
+** EPITECH PROJECT, 2019
+** int formater
+** File description:
+** int_formater
+*/
+
+#include "formaters.h"
+#include "my.h"
+#include <stdarg.h>
+#include <unistd.h>
+
+int ubinary_formater(va_list ap, char mod[MODIFIERS_SIZE])
+{
+    long long int var;
+    int nbrlen;
+
+    if (count('l', mod) >= 2)
+        var = va_arg(ap, unsigned long long int);
+    else if (count('l', mod) == 1)
+        var = va_arg(ap, unsigned long);
+    else
+        var = va_arg(ap, unsigned int);
+    if (contains('0', mod))
+        nbrlen = my_getnbr(&mod[last_mod(mod)]);
+    else
+        nbrlen = 0;
+    return (my_putlonglong_base(var, "01", nbrlen));
+}

lib/my/src/formaters/uint_formater.c

@@ -0,0 +1,29 @@
+/*
+** EPITECH PROJECT, 2019
+** int formater
+** File description:
+** int_formater
+*/
+
+#include "formaters.h"
+#include "my.h"
+#include <stdarg.h>
+#include <unistd.h>
+
+int uint_formater(va_list ap, char mod[MODIFIERS_SIZE])
+{
+    long long int var;
+    int nbrlen;
+
+    if (count('l', mod) >= 2)
+        var = va_arg(ap, unsigned long long int);
+    else if (count('l', mod) == 1)
+        var = va_arg(ap, unsigned long);
+    else
+        var = va_arg(ap, unsigned int);
+    if (contains('0', mod))
+        nbrlen = my_getnbr(&mod[last_mod(mod)]);
+    else
+        nbrlen = 0;
+    return (my_putlonglong_base(var, "0123456789", nbrlen));
+}

lib/my/src/get_nbr_size.c

@@ -0,0 +1,24 @@
+/*
+** EPITECH PROJECT, 2019
+** Get nbr size
+** File description:
+** get_nbr_size
+*/
+
+#include "my.h"
+
+int get_nbr_len(long long int n, const char *base)
+{
+    int base_size = my_strlen(base);
+    int i = 1;
+
+    if (n < 0) {
+        n *= -1;
+        i++;
+    }
+    while (n >= base_size) {
+        n /= base_size;
+        i++;
+    }
+    return (i);
+}

lib/my/src/my_putlonglong_base.c

@@ -0,0 +1,42 @@
+/*
+** EPITECH PROJECT, 2019
+** Put nbr in a custom base
+** File description:
+** Might be useful later
+*/
+
+#include <unistd.h>
+#include "formaters.h"
+
+int my_strlen(const char *str);
+
+static void display_a_digit(char c)
+{
+    write(1, &c, 1);
+}
+
+static void put_digit(long long int n, int base_length, const char *base)
+{
+    if (n > base_length - 1)
+        put_digit(n / base_length, base_length, base);
+    display_a_digit(base[n % base_length]);
+}
+
+int my_putlonglong_base(long long int nbr, const char *base, int nbrlen)
+{
+    int base_length = my_strlen(base);
+
+    if (base_length < 2) {
+        display_a_digit(base[0]);
+        return (0);
+    }
+    if (nbr < 0) {
+        nbr *= -1;
+        display_a_digit('-');
+        nbrlen--;
+    }
+    for (int i = get_nbr_len(nbr, base); i < nbrlen; i++)
+        write(1, base, 1);
+    put_digit(nbr, base_length, base);
+    return (nbrlen + nbr < 0 ? 1 : 0);
+}

lib/my/src/printf.c

@@ -0,0 +1,95 @@
+/*
+** EPITECH PROJECT, 2019
+** Sum stdarg
+** File description:
+** sum_stdarg
+*/
+
+#include "formaters.h"
+#include "my.h"
+#include <stdarg.h>
+#include <unistd.h>
+
+formater_t formaters[] = {{string_formater, 's'},
+                          {string_nonprintable_formater, 'S'},
+                          {char_formater, 'c'},
+                          {int_formater, 'i'},
+                          {int_formater, 'd'},
+                          {octal_formater, 'o'},
+                          {hexa_formater, 'x'},
+                          {big_hexa_formater, 'X'},
+                          {uint_formater, 'u'},
+                          {ptr_formater, 'p'},
+                          {ubinary_formater, 'b'},
+                          {float_formater, 'f'},
+                          {float_formater, 'F'},
+                          {no_format, '%'},
+                          {0, 0}};
+
+const char modifiersCst[] = "#0-+ hl";
+
+int format(va_list ap, char flag, char modifiers[MODIFIERS_SIZE])
+{
+    for (int i = 0; formaters[i].flag; i++) {
+        if (formaters[i].flag == flag) {
+            return (formaters[i].func(ap, modifiers));
+        }
+    }
+    return (0);
+}
+
+int is_flag(char c)
+{
+    for (int i = 0; formaters[i].flag; i++) {
+        if (formaters[i].flag == c) {
+            return (1);
+        }
+    }
+    return (0);
+}
+
+int is_modifier(char c)
+{
+    for (int i = 0; modifiersCst[i]; i++) {
+        if (modifiersCst[i] == c)
+            return (1);
+    }
+    return (0);
+}
+
+int get_modifiers(const char *str, char flags[MODIFIERS_SIZE])
+{
+    int i;
+
+    for (i = 0; !is_flag(str[i]); i++) {
+        if (!is_modifier(str[i]) && !is_num(str[i]))
+            return (-1);
+        flags[i] = str[i];
+    }
+    flags[i] = '\0';
+    return (i);
+}
+
+int my_printf(const char *str, ...)
+{
+    int count = 0;
+    va_list ap;
+    char modifiers[MODIFIERS_SIZE];
+    int next_is_flag;
+
+    va_start(ap, str);
+    for (int i = 0; str[i]; i++) {
+        if (str[i] == '%') {
+            next_is_flag = 1;
+            i++;
+            i += get_modifiers(&str[i], modifiers);
+        } else
+            next_is_flag = 0;
+        if (next_is_flag && is_flag(str[i]))
+            count += format(ap, str[i], modifiers);
+        else
+            count += write(1, &str[i], 1);
+    }
+    va_end(ap);
+    return (count);
+}

lib/my/src/printf_utility.c

@@ -0,0 +1,37 @@
+/*
+** EPITECH PROJECT, 2019
+** Utility for the flags
+** File description:
+** utility
+*/
+
+#include "formaters.h"
+
+int count(char c, char *str)
+{
+    int count = 0;
+
+    for (int i = 0; str[i]; i++) {
+        if (str[i] == c)
+            count++;
+    }
+    return (count);
+}
+
+int contains(char c, char *str)
+{
+    for (int i = 0; str[i]; i++) {
+        if (str[i] == c)
+            return (1);
+    }
+    return (0);
+}
+
+int last_mod(char *modifiers)
+{
+    for (int i = 0; modifiers[i]; i++) {
+        if (!is_modifier(modifiers[i]))
+            return (i);
+    }
+    return (0);
+}

lib/my/tests/test_printf.c

@@ -0,0 +1,176 @@
+/*
+** EPITECH PROJECT, 2019
+** Tests
+** File description:
+** test_disp_stdarg
+*/
+
+#include <criterion/criterion.h>
+#include <criterion/redirect.h>
+#include "my.h"
+
+Test(disp, first, .init = cr_redirect_stdout)
+{
+    my_printf("Insane %s, %c, %d, %s\n", "Yes", '8', 15, "Nope");
+    cr_assert_stdout_eq_str("Insane Yes, 8, 15, Nope\n");
+}
+
+Test(disp, faketag, .init = cr_redirect_stdout)
+{
+    my_printf("Insane %Y, %c, %d, %s\n", '8', 15, "Nope");
+    cr_assert_stdout_eq_str("Insane %Y, 8, 15, Nope\n");
+}
+
+Test(disp, str, .init = cr_redirect_stdout)
+{
+    my_printf("Insane %s\n", "156615");
+    cr_assert_stdout_eq_str("Insane 156615\n");
+}
+
+Test(disp, uints, .init = cr_redirect_stdout)
+{
+    my_printf("Insane %u\n", 156615);
+    cr_assert_stdout_eq_str("Insane 156615\n");
+}
+
+Test(disp, characters, .init = cr_redirect_stdout)
+{
+    my_printf("Insane %c\n", '^');
+    cr_assert_stdout_eq_str("Insane ^\n");
+}
+
+Test(disp, ints, .init = cr_redirect_stdout)
+{
+    my_printf("Insane %d, %i\n", 15, -15);
+    cr_assert_stdout_eq_str("Insane 15, -15\n");
+}
+
+Test(disp, ptr, .init = cr_redirect_stdout)
+{
+    int ptr = 15;
+    char *str = malloc(sizeof(char) * 25);
+
+    my_printf("Insane %p\n", &ptr);
+    sprintf(str, "Insane %p\n", &ptr);
+    cr_assert_stdout_eq_str(str);
+}
+
+Test(disp, nonprintable, .init = cr_redirect_stdout)
+{
+    my_printf("Insane %S\n", "\aYes\a");
+    cr_assert_stdout_eq_str("Insane \\007Yes\\007\n");
+}
+
+Test(disp, binary, .init = cr_redirect_stdout)
+{
+    my_printf("%b\n", 153152);
+    cr_assert_stdout_eq_str("100101011001000000\n");
+}
+
+Test(disp, octal, .init = cr_redirect_stdout)
+{
+    my_printf("%o\n", 153152);
+    cr_assert_stdout_eq_str("453100\n");
+}
+
+Test(disp, hexa, .init = cr_redirect_stdout)
+{
+    my_printf("%x\n", 1561356523);
+    cr_assert_stdout_eq_str("5d1068eb\n");
+}
+
+Test(disp, bighexa, .init = cr_redirect_stdout)
+{
+    my_printf("%X\n", 1561356523);
+    cr_assert_stdout_eq_str("5D1068EB\n");
+}
+
+Test(disp, uintneg, .init = cr_redirect_stdout)
+{
+    my_printf("%u\n", -500);
+    cr_assert_stdout_eq_str("4294966796\n");
+}
+
+Test(disp, noformat, .init = cr_redirect_stdout)
+{
+    my_printf("%%\n");
+    cr_assert_stdout_eq_str("%\n");
+}
+
+Test(disp, floats, .init = cr_redirect_stdout)
+{
+    my_printf("%f\n", 13.684);
+    cr_assert_stdout_eq_str("13.684\n");
+}
+
+Test(disp, morefloat, .init = cr_redirect_stdout)
+{
+    my_printf("%f\n", 18.138613);
+    cr_assert_stdout_eq_str("18.138613\n");
+}
+
+Test(my_printf, mouliS, .init = cr_redirect_stdout)
+{
+    my_printf("%S", "mouline\atte\n");
+    cr_assert_stdout_eq_str("mouline\\007tte\\012");
+}
+
+Test(my_printf, simplePtr, .init = cr_redirect_stdout)
+{
+    my_printf("%p", 3456789);
+    cr_assert_stdout_eq_str("0x34bf15");
+}
+
+Test(my_printf, intLength, .init = cr_redirect_stdout)
+{
+    my_printf("%05i", 15);
+    cr_assert_stdout_eq_str("00015");
+}
+
+Test(my_printf, intPlusSize, .init = cr_redirect_stdout)
+{
+    my_printf("%0+5i", 15);
+    cr_assert_stdout_eq_str("+0015");
+}
+
+Test(my_printf, intLengthSpace, .init = cr_redirect_stdout)
+{
+    my_printf("% 05i", 15);
+    cr_assert_stdout_eq_str(" 0015");
+}
+
+Test(my_printf, intLengthSpacePlus, .init = cr_redirect_stdout)
+{
+    my_printf("% 0+5i", -15);
+    cr_assert_stdout_eq_str("-0015");
+}
+
+Test(my_printf, xLength, .init = cr_redirect_stdout)
+{
+    my_printf("%05X", 15);
+    cr_assert_stdout_eq_str("0000F");
+}
+
+Test(my_printf, xPlusSize, .init = cr_redirect_stdout)
+{
+    my_printf("%0+5X", 15);
+    cr_assert_stdout_eq_str("0000F");
+}
+
+Test(my_printf, xLengthSpace, .init = cr_redirect_stdout)
+{
+    my_printf("%#X", -15);
+    cr_assert_stdout_eq_str("0XFFFFFFF1");
+}
+
+Test(my_printf, xLengthSpacePlus, .init = cr_redirect_stdout)
+{
+    my_printf("%# +X", -15);
+    cr_assert_stdout_eq_str("0XFFFFFFF1");
+}
+
+Test(my_printf, stringWithMax, .init = cr_redirect_stdout)
+{
+    my_printf("%# +03s", "ABCDEFG");
+    cr_assert_stdout_eq_str("ABC");
+}

prefabs/game.gcprefab

@@ -1,75 +1,75 @@
 <gc_scene>
     <gc_entities>
         <gc_entity>
-            <TransformComponent>
+            <transform_component>
                 <Position x="0" y="600" />
                 <Size x="800" y="600" />
-            </TransformComponent>
-            <Renderer src="assets/sprites/bck_layer4.png">
+            </transform_component>
+            <renderer src="assets/sprites/bck_layer4.png">
                 <Rect height="auto" width="auto" top="0" left="0" /> 
-            </Renderer>
-            <ParallaxComponent speed="60" />
+            </renderer>
+            <parallax_component speed="60" />
         </gc_entity>
         <gc_entity>
-            <TransformComponent>
+            <transform_component>
                 <Position x="0" y="600" />
                 <Size x="800" y="600" />
-            </TransformComponent>
-            <Renderer src="assets/sprites/bck_layer3.png">
+            </transform_component>
+            <renderer src="assets/sprites/bck_layer3.png">
                 <Rect height="auto" width="auto" top="0" left="0" /> 
-            </Renderer>
-            <ParallaxComponent speed="90" />
+            </renderer>
+            <parallax_component speed="90" />
         </gc_entity>
         <gc_entity>
-            <TransformComponent>
+            <transform_component>
                 <Position x="0" y="600" />
                 <Size x="800" y="600" />
-            </TransformComponent>
-            <Renderer src="assets/sprites/bck_layer2.png">
+            </transform_component>
+            <renderer src="assets/sprites/bck_layer2.png">
                 <Rect height="auto" width="auto" top="0" left="0" /> 
-            </Renderer>
-            <ParallaxComponent speed="100" />
+            </renderer>
+            <parallax_component speed="100" />
         </gc_entity>
         <gc_entity>
-            <TransformComponent>
+            <transform_component>
                 <Position x="0" y="600" />
                 <Size x="800" y="600" />
-            </TransformComponent>
-            <Renderer src="assets/sprites/bck_layer1.png">
+            </transform_component>
+            <renderer src="assets/sprites/bck_layer1.png">
                 <Rect height="auto" width="auto" top="0" left="0" /> 
-            </Renderer>
-            <ParallaxComponent speed="120" />
+            </renderer>
+            <parallax_component speed="120" />
         </gc_entity>
         
         <gc_entity>
-            <TransformComponent>
+            <transform_component>
                 <Position x="200" y="100" />
                 <Size x="500" y="50" />
-            </TransformComponent>
-            <Renderer src="assets/sprites/grass.png">
+            </transform_component>
+            <renderer src="assets/sprites/grass.png">
                 <Rect height="auto" width="auto" top="0" left="0" /> 
-            </Renderer>
-            <MovableComponent />
+            </renderer>
+            <movable_component />
         </gc_entity>
         <gc_entity>
-            <TransformComponent>
+            <transform_component>
                 <Position x="100" y="400" />
                 <Size x="100" y="300" />
-            </TransformComponent>
-            <Renderer src="assets/sprites/grass.png">
+            </transform_component>
+            <renderer src="assets/sprites/grass.png">
                 <Rect height="auto" width="auto" top="0" left="0" /> 
-            </Renderer>
-            <MovableComponent />
+            </renderer>
+            <movable_component />
         </gc_entity>
         <gc_entity>
-            <TransformComponent>
+            <transform_component>
                 <Position x="700" y="400" />
                 <Size x="100" y="300" />
-            </TransformComponent>
-            <Renderer src="assets/sprites/grass.png">
+            </transform_component>
+            <renderer src="assets/sprites/grass.png">
                 <Rect height="auto" width="auto" top="0" left="0" /> 
-            </Renderer>
-            <MovableComponent />
+            </renderer>
+            <movable_component />
         </gc_entity>
     </gc_entities>
 </gc_scene>

prefabs/player.gcprefab

@@ -1,14 +1,17 @@
 <gc_entities>
     <gc_entity>
-        <TransformComponent>
+        <transform_component>
             <Position x="300" y="300" />
             <Size x="50" y="50" />
-        </TransformComponent>
-        <Renderer src="assets/sprites/grass.png">
+        </transform_component>
+        <renderer src="assets/sprites/grass.png">
             <Rect height="auto" width="auto" top="0" left="0" /> 
-        </Renderer>
-        <MovableComponent />
-        <ControllableComponent left="16" right="3" jump=" " speed="700" />
-        <GravityComponent speed="50" max_speed="100" />
+        </renderer>
+        <movable_component />
+        <controllable_component />
+        <gravity_component speed="50" />
+        <keyboard_controller left="16" right="3" jump="57" />
+        <walk_action speed="14000" max_speed="500" max_acceleration="14000" />
+        <friction_component value="1500" />
     </gc_entity>
 </gc_entities>