ft_printf

ft_printf is a milestone M1 project in C, done solo. You recreate a subset of the libc printf: a function that takes a format string and a variable number of arguments, prints the result on standard output and returns the number of characters written. It is packed as libftprintf.a and usually built on top of your libft. Behind the small surface it is a lesson in variadic functions and in writing a parser that is easy to extend.

What you will learn

• Variadic functions with va_start, va_arg, va_copy and va_end, and the default argument promotions (char becomes int)
• Parsing a format string one character at a time and dispatching on the conversion
• Converting numbers to any base, signed and unsigned, without overflow
• Printing pointers as hexadecimal addresses
• Counting output precisely and propagating write errors
• Designing a small dispatch table so the bonus flags do not turn into one giant function

Before you start

• Previous nodes: Libft. You will reuse ft_putchar_fd, ft_strlen and probably ft_itoa-style helpers.
• Tools: cc, make, ar, norminette, valgrind.
• Read man 3 printf (the "Conversion specifiers" and "Flag characters" sections) and man 3 stdarg.
• The mandatory conversions are %c, %s, %p, %d, %i, %u, %x, %X and %%.

Plan of attack

1. Day 1: write a skeleton that copies the format string to stdout and returns the count. Add the Makefile so libftprintf.a contains your libft objects too (or merge libft sources into the build).
2. Day 1: add %c, %s and %%. Decide what %s prints for NULL and match the real printf on your system ((null) on glibc).
3. Day 2: write one generic put_unsigned_base(value, base_digits) and use it for %u, %x and %X.
4. Day 2: %d and %i, handling INT_MIN without negating it as an int (cast to long first).
5. Day 3: %p. Cast to unsigned long (or uintptr_t), prefix with 0x, and check what your system prints for a NULL pointer ((nil) on Linux, 0x0 on macOS).
6. Day 3: compare your output and return value with the real printf for every conversion, side by side, in a test main kept outside the repository.
7. Day 4 (bonus): parse flags -0. and field width, then # + and space. Store them in a small struct and pass the struct to each converter.
8. Day 5: norminette, valgrind, a tester, and a final read of the parser.

int	ft_printf(const char *format, ...)
{
	va_list	args;
	int		count;

	va_start(args, format);
	count = print_format(format, &args);
	va_end(args);
	return (count);
}

Common pitfalls

• Using the real printf or sprintf inside the project: forbidden.
• Return value off by one when a conversion prints nothing (empty string, precision zero in the bonus).
• %x with negative numbers: the argument is an unsigned int, read it as such.
• INT_MIN and UINT_MAX edge cases.
• Calling va_arg with char instead of int: undefined behaviour.
• A Makefile that relinks, or a library that does not contain the libft objects it needs.
• Forgetting the bonus rule while claiming the bonus.
• Behaviour with a trailing lone % is undefined; do not crash on it.

How it is evaluated

• Peer evaluation then Moulinette. The evaluator checks the Makefile (no relink, libftprintf.a produced), norminette and the absence of forbidden functions.
• Each conversion is tested against the real printf: same output and same return value, including NULL strings, NULL pointers, 0, INT_MIN, INT_MAX and UINT_MAX.
• Leaks are checked on a test main.
• The bonus is graded only if the mandatory part is perfect. Flags are tested in combination (%-10.5d, %#x, % d, %+d).
• You must explain how va_arg works and why your design is extensible.

Resources

• printf(3) man page
• stdarg(3) man page
• printfTester by Tripouille
• norminette on GitHub
• francinette image fork for C projects