Libft

Libft is the first project of the core (milestone M0) and the one every later C project leans on. Working solo in C, you rewrite a selection of libc functions, add a set of string and memory helpers that libc does not have, and (bonus) a small singly linked list API. The result is a static library, libft.a, built by your own Makefile, that you will copy into ft_printf, get_next_line, push_swap and Codexion. Treat it as a tool you will keep, not as a box to tick.

What you will learn

• How the classic libc functions really behave: strlcpy, strlcat, strnstr, atoi, memmove and friends, including their odd corners
• Pointer arithmetic, const correctness and the difference between char *, unsigned char * and void *
• Heap allocation with malloc and free, and returning NULL cleanly when an allocation fails
• Writing a Makefile with all, clean, fclean, re and bonus rules that does not relink
• Building and linking a static library with ar rcs
• Writing to file descriptors with write (the ft_put*_fd family)
• Linked lists with function pointers (ft_lstiter, ft_lstmap)

Before you start

• Previous nodes: none. You should be comfortable with the C Piscine level: loops, pointers, write, compiling with cc.
• Tools: cc (gcc or clang), make, ar, valgrind (Linux) or leaks (macOS), and norminette (python3 -m pip install norminette).
• Read the man pages of every libc function you have to copy before you write a line. The man page is the specification.
• Set up a test folder outside the repository so test files never end up in your submission.

Plan of attack

1. Day 1: write the Makefile first, with -Wall -Wextra -Werror, an object list and a libft.a target. Check that make twice in a row prints "Nothing to be done".
2. Day 1: the character tests (ft_isalpha, ft_isdigit, ft_isalnum, ft_isascii, ft_isprint, ft_toupper, ft_tolower). Compare each against the real function for every value from -1 to 255.
3. Day 2: the memory functions (ft_memset, ft_bzero, ft_memcpy, ft_memmove, ft_memchr, ft_memcmp). Draw the overlap cases for memmove on paper before coding them.
4. Day 2: the string functions (ft_strlen, ft_strlcpy, ft_strlcat, ft_strchr, ft_strrchr, ft_strncmp, ft_strnstr, ft_atoi), then ft_calloc and ft_strdup.
5. Day 3: the part 2 functions that allocate: ft_substr, ft_strjoin, ft_strtrim, ft_split, ft_itoa, ft_strmapi, ft_striteri.
6. Day 4: ft_split deserves its own day. Free every word already allocated if one allocation fails, and test with separators at the start, at the end, repeated and absent.
7. Day 4: the ft_put*_fd functions, then the bonus list functions with a bonus rule.
8. Day 5: run norminette on every file, run two testers, run valgrind on your own main, and read your code once more as if you were the evaluator.

A tiny test harness is enough to start:

#include "libft.h"
#include <stdio.h>
#include <string.h>

int	main(void)
{
	char	a[10] = "abcdef";
	char	b[10] = "abcdef";

	memmove(a + 2, a, 4);
	ft_memmove(b + 2, b, 4);
	printf("%s | %s\n", a, b);
	return (0);
}

Common pitfalls

• Norm errors: more than 25 lines per function, more than 5 functions per file, declarations mixed with code, forbidden for loops. One norm error is a 0.
• Relinking: if make rebuilds libft.a when nothing changed, the evaluation fails.
• ft_strlcat return value when size is smaller than the destination length.
• ft_atoi with leading whitespace, a single sign, and values near INT_MIN.
• ft_calloc with nmemb * size overflowing SIZE_MAX.
• ft_substr when start is past the end of the string: return an empty allocated string, not NULL.
• ft_split leaking the array or the words when a malloc fails halfway.
• ft_memmove copying forward when the destination overlaps the end of the source.
• Forgetting to protect against NULL where your own later projects will need it (the subject does not require it, so be consistent and able to justify your choice).

How it is evaluated

• Peer evaluation, then Moulinette. The evaluator first checks the repository: only the allowed files, a Makefile with the required rules, no relink, and norminette clean.
• Every function is tested, usually with a tester and with hand-written edge cases. A crash, a segfault, a wrong return value or a leak on one function is enough to fail.
• The bonus (linked list functions) is only graded if the mandatory part is perfect.
• Expect questions on any line: why unsigned char in ft_memcmp, how ft_memmove handles overlap, what ar does.

Resources

• Linux man pages online
• norminette on GitHub
• libftTester by Tripouille
• francinette image fork for C projects
• GNU make manual
• Valgrind quick start