ft_printf

% [flags] [width] [.precision] [length] conversion
     │           │           │             │            │
     │           │           │             │            └─ sSpdDioOuUxXcC %
     │           │           │             └─ hh h l ll j z
     │           │           └─ . puis chiffres ou *
     │           └─ chiffres ou *  (largeur min du champ)
     └─ # 0 - + espace  (dans n'importe quel ordre)

int   ft_printf(const char *format, ...)
{
    va_list ap;
    t_buf   buf;
    int     ret;

    buf.len   = 0;
    buf.total = 0;
    va_start(ap, format);          /* 1. initialiser le curseur après 'format' */
    process_format(format, &ap, &buf); /* 2. parser + dispatcher + buffer */
    va_end(ap);                    /* 3. nettoyer */
    buf_flush(&buf);                /* 4. écrire le reste du buffer */
    return (buf.total);
}

/* BIEN : pointeur sur va_list, l'avance est visible partout */
void  conv_int(t_conv *c, va_list *ap, t_buf *buf)
{
    long long n;

    n = va_arg(*ap, int);   /* consomme un int, visible par l'appelant */
    ...
}

/* MAL : copie locale, l'appelant ne voit pas l'avance sur certaines plateformes */
void  conv_int_broken(t_conv *c, va_list ap, t_buf *buf)
{
    long long n = va_arg(ap, int); /* l'avance reste locale */
    ...
}

static void  process_format(const char *fmt, va_list *ap, t_buf *buf)
{
    t_conv  conv;

    while (*fmt)
    {
        if (*fmt != '%')
        {
            buf_char(buf, *fmt);   /* texte littéral → buffer direct */
            fmt++;
            continue;
        }
        fmt++;                            /* skip '%' */
        conv.flags     = 0;
        conv.width     = 0;
        conv.precision = -1;          /* -1 = non spécifiée */
        conv.length    = LEN_NONE;
        conv.conv      = 0;
        fmt = parse_conv(fmt, &conv, ap);  /* remplit conv */
        if (conv.conv)
            dispatch(&conv, ap, buf);        /* route vers le handler */
        else if (*fmt)                      /* spec invalide → imprime % + char */
        {
            buf_char(buf, '%');
            buf_char(buf, *fmt);
            fmt++;
        }
        else
            buf_char(buf, '%');   /* '%' final solitaire */
    }
}

int   dispatch(t_conv *c, va_list *ap, t_buf *buf)
{
    char  conv = c->conv;

    if (conv == 'd' || conv == 'i' || conv == 'D')
        conv_int(c, ap, buf);
    else if (conv == 'u' || conv == 'U')
        conv_uint(c, ap, buf);
    else if (conv == 'o' || conv == 'O')
        conv_oct(c, ap, buf);
    else if (conv == 'x' || conv == 'X')
        conv_hex(c, ap, buf);
    else if (conv == 'c' || conv == 'C')
        conv_char(c, ap, buf);
    else if (conv == 's' || conv == 'S')
        conv_str(c, ap, buf);
    else if (conv == 'p')
        conv_ptr(c, ap, buf);
    else if (conv == '%')
        conv_percent(c, ap, buf);
    return (0);
}

typedef void (*t_handler)(t_conv*, va_list*, t_buf*);

/* Table indexée par code ASCII ; NULL pour les chars sans handler. */
static t_handler g_table[128] = {
    ['d'] = conv_int,  ['i'] = conv_int,  ['D'] = conv_int,
    ['u'] = conv_uint, ['U'] = conv_uint,
    ['o'] = conv_oct,  ['O'] = conv_oct,
    ['x'] = conv_hex,  ['X'] = conv_hex,
    ['c'] = conv_char, ['C'] = conv_char,
    ['s'] = conv_str,  ['S'] = conv_str,
    ['p'] = conv_ptr,
    ['%'] = conv_percent,
};

int   dispatch(t_conv *c, va_list *ap, t_buf *buf)
{
    unsigned char  conv = (unsigned char)c->conv;

    if (conv < 128 && g_table[conv])
        g_table[conv](c, ap, buf);
    return (0);
}

#define FLAG_HASH   (1 << 0)   /* #  */
#define FLAG_ZERO   (1 << 1)   /* 0  */
#define FLAG_MINUS  (1 << 2)   /* -  */
#define FLAG_PLUS   (1 << 3)   /* +  */
#define FLAG_SPACE  (1 << 4)   /* ' '*/

typedef enum e_len {
    LEN_NONE = 0, LEN_HH, LEN_H, LEN_L, LEN_LL, LEN_J, LEN_Z
}              t_len;

const char *parse_conv(const char *fmt, t_conv *c, va_list *ap)
{
    parse_flags(&fmt, c);
    parse_width(&fmt, c, ap);
    parse_precision(&fmt, c, ap);
    parse_length(&fmt, c);
    if (*fmt)
    {
        c->conv = *fmt;
        fmt++;
    }
    return (fmt);
}

static void  parse_flags(const char **fmt, t_conv *c)
{
    while (**fmt == '#' || **fmt == '0' || **fmt == '-' ||
           **fmt == '+' || **fmt == ' ')
    {
        if (**fmt == '#')     c->flags |= FLAG_HASH;
        else if (**fmt == '0')  c->flags |= FLAG_ZERO;
        else if (**fmt == '-')  c->flags |= FLAG_MINUS;
        else if (**fmt == '+')  c->flags |= FLAG_PLUS;
        else if (**fmt == ' ')  c->flags |= FLAG_SPACE;
        (*fmt)++;
    }
}

static void  parse_width(const char **fmt, t_conv *c, va_list *ap)
{
    if (**fmt == '*')
    {
        c->width = va_arg(*ap, int);
        if (c->width < 0)           /* width négative = flag '-' implicite */
        {
            c->flags |= FLAG_MINUS;
            c->width = -c->width;
        }
        (*fmt)++;
    }
    else if (**fmt >= '0' && **fmt <= '9')
        c->width = ft_atoi(fmt);  /* avance fmt */
}

static void  parse_precision(const char **fmt, t_conv *c, va_list *ap)
{
    if (**fmt == '.')
    {
        (*fmt)++;
        c->precision = 0;             /* "." seul = précision 0 */
        if (**fmt == '*')
        {
            c->precision = va_arg(*ap, int);
            if (c->precision < 0)
                c->precision = -1;     /* précision négative = ignorée */
            (*fmt)++;
        }
        else
            c->precision = ft_atoi(fmt);
    }
}

static void  parse_length(const char **fmt, t_conv *c)
{
    if ((*fmt)[0] == 'h' && (*fmt)[1] == 'h')  { c->length = LEN_HH; *fmt += 2; }
    else if ((*fmt)[0] == 'h')                    { c->length = LEN_H;  (*fmt)++; }
    else if ((*fmt)[0] == 'l' && (*fmt)[1] == 'l')  { c->length = LEN_LL; *fmt += 2; }
    else if ((*fmt)[0] == 'l')                    { c->length = LEN_L;  (*fmt)++; }
    else if ((*fmt)[0] == 'j')                    { c->length = LEN_J;  (*fmt)++; }
    else if ((*fmt)[0] == 'z')                    { c->length = LEN_Z;  (*fmt)++; }
}

void  conv_int(t_conv *c, va_list *ap, t_buf *buf)
{
    long long  n;
    char       num[32];
    int        num_len;
    char       sign;

    /* 1. LIRE — promotion selon length modifier */
    if      (c->length == LEN_HH) n = (signed char)va_arg(*ap, int);
    else if (c->length == LEN_H)  n = (short)va_arg(*ap, int);
    else if (c->length == LEN_L)  n = va_arg(*ap, long);
    else if (c->length == LEN_LL) n = va_arg(*ap, long long);
    else                       n = va_arg(*ap, int);

    /* 2. SIGNE — mémorisé à part, n devient valeur absolue (en ull) */
    sign = 0;
    if (n < 0)                  { sign = '-'; n = -n; }
    else if (c->flags & FLAG_PLUS)  sign = '+';
    else if (c->flags & FLAG_SPACE) sign = ' ';

    /* 3. CONVERTIR en base 10 (digits écrits à l'envers) puis reverse */
    ull_to_base((unsigned long long)n, 10, 0, num, &num_len);
    reverse(num, num_len);   /* helper — voir utils */

    /* 4. PRÉCISION — précision 0 + valeur 0 → affiche rien */
    if (c->precision == 0 && n == 0)
        num_len = 0;
    else if (c->precision > num_len)
        num_len = prepend_zeros(num, num_len, c->precision);

    /* 5. DÉSACTIVER '0' si précision donnée (règle du man) */
    if (c->precision != -1)
        c->flags &= ~FLAG_ZERO;

    /* 6. PADDING selon flags '-' / '0' / rien */
    apply_padding(c, buf, num, num_len, sign, "", 0);
}

void  conv_oct(t_conv *c, va_list *ap, t_buf *buf)
{
    unsigned long long  n;
    char                num[32];
    char               *prefix = "";
    int                 prefix_len = 0;

    n = read_unsigned(c, ap);                 /* selon length */
    ull_to_base(n, 8, 0, num, &num_len);
    reverse(num, num_len);

    if (c->flags & FLAG_HASH)               /* '#' → préfixe "0" */
    {
        prefix = "0";
        prefix_len = 1;
    }
    /* Note : pour octal, '#' interagit avec la précision :
       si precision <= 1 et n==0, le '0' du préfixe compte dans la précision. */
    if (c->precision == 0 && n == 0 && !(c->flags & FLAG_HASH))
        num_len = 0;
    /* ... précision (prepend zeros), disable '0' flag, apply_padding ... */
    apply_padding(c, buf, num, num_len, 0, prefix, prefix_len);
}

void  conv_hex(t_conv *c, va_list *ap, t_buf *buf)
{
    unsigned long long  n;
    char                num[32];
    int                 upper  = (c->conv == 'X');
    char               *prefix = "";
    int                 prefix_len = 0;

    n = read_unsigned(c, ap);
    ull_to_base(n, 16, upper, num, &num_len);  /* digits ABCDEF si upper */
    reverse(num, num_len);

    /* '#' ajoute 0x/0X UNIQUEMENT si n != 0 */
    if (c->flags & FLAG_HASH && n != 0)
    {
        prefix     = upper ? "0X" : "0x";
        prefix_len = 2;
    }
    if (c->precision == 0 && n == 0)
        num_len = 0;
    /* ... précision, disable '0', apply_padding ... */
    apply_padding(c, buf, num, num_len, 0, prefix, prefix_len);
}

void  conv_str(t_conv *c, va_list *ap, t_buf *buf)
{
    char *s;
    int  len;

    s = va_arg(*ap, char *);
    if (s == NULL)                       /* gère NULL → "(null)" */
        s = "(null)";
    len = ft_strlen(s);
    if (c->precision != -1 && c->precision < len)
        len = c->precision;            /* précision = max chars (troncature) */

    if (c->flags & FLAG_MINUS)           /* aligné à gauche */
    {
        buf_str(buf, s, len);
        buf_pad(buf, ' ', c->width - len > 0 ? c->width - len : 0);
    }
    else                                /* aligné à droite (défaut) */
    {
        buf_pad(buf, ' ', c->width - len > 0 ? c->width - len : 0);
        buf_str(buf, s, len);
    }
}

void  conv_ptr(t_conv *c, va_list *ap, t_buf *buf)
{
    unsigned long long  addr;
    char                num[32];
    int                 num_len;

    addr = (unsigned long long)va_arg(*ap, void *);
    ull_to_base(addr, 16, 0, num, &num_len);
    reverse(num, num_len);

    /* "0x" TOUJOURS, même pour NULL → "0x0" */
    apply_padding(c, buf, num, num_len, 0, "0x", 2);
}

static void  apply_padding(t_conv *c, t_buf *buf,
                              char *content, int content_len,
                              char sign, char *prefix, int prefix_len)
{
    int   total_len = content_len + (sign ? 1 : 0) + prefix_len;
    int   pad      = c->width - total_len;
    char  pad_char = (c->flags & FLAG_ZERO && !(c->flags & FLAG_MINUS)
                          && c->precision == -1) ? '0' : ' ';

    if (c->flags & FLAG_MINUS)              /* '-' : contenu puis espaces */
    {
        if (sign)  buf_char(buf, sign);
        buf_str(buf, prefix, prefix_len);
        buf_str(buf, content, content_len);
        buf_pad(buf, ' ', pad > 0 ? pad : 0);
    }
    else if (pad_char == '0')            /* '0' : signe+prefix+zéros+chiffres */
    {
        if (sign)  buf_char(buf, sign);
        buf_str(buf, prefix, prefix_len);
        buf_pad(buf, '0', pad > 0 ? pad : 0);
        buf_str(buf, content, content_len);
    }
    else                                /* défaut : espaces puis contenu */
    {
        buf_pad(buf, ' ', pad > 0 ? pad : 0);
        if (sign)  buf_char(buf, sign);
        buf_str(buf, prefix, prefix_len);
        buf_str(buf, content, content_len);
    }
}

/* '0' est invalide si :                                   */
/*   1. '-' est présent   (le '-' aligne à gauche)          */
/*   2. une précision est donnée pour un nombre            */
/*      (la précision gère déjà les zéros significatifs)   */

if (c->precision != -1)
    c->flags &= ~FLAG_ZERO;     /* disable '0' */

/* Le '-' est géré directement dans apply_padding : le test */
/* (c->flags & FLAG_ZERO && !(c->flags & FLAG_MINUS))        */
/* garantit que '-' gagne toujours.                         */

/* %*.*d : arg1=largeur, arg2=précision, arg3=valeur */
ft_printf("%*.*d", 8, 3, 42);
/*             ^   ^   ^                                  */
/*             |   |   └─ valeur à afficher             */
/*             |   └───── précision (3)                  */
/*             └───────── largeur (8)                    */
/* → "     042"  (5 espaces + "042")                     */

#define BUFF_SIZE 4096    /* taille d'une page mémoire typique */

typedef struct s_buf {
    char data[BUFF_SIZE];   /* stockage local */
    int  len;                /* octets actuellement stockés */
    int  total;              /* compteur logique (return value) */
}         t_buf;

/* Flush : vide le buffer sur stdout en un seul write */
void  buf_flush(t_buf *buf)
{
    if (buf->len > 0)
    {
        write(1, buf->data, buf->len);
        buf->len = 0;
    }
}

/* Ajoute un caractère ; flush automatique si plein */
void  buf_char(t_buf *buf, char c)
{
    if (buf->len >= BUFF_SIZE)   /* débordement → on vide d'abord */
        buf_flush(buf);
    buf->data[buf->len] = c;
    buf->len++;
    buf->total++;              /* compte logique toujours incrémenté */
}

/* Ajoute une chaîne de longueur connue */
void  buf_str(t_buf *buf, const char *s, int len)
{
    int  i = 0;
    while (i < len)
        buf_char(buf, s[i++]);   /* gère le flush auto */
}

/* Ajoute n fois le caractère c (pour le padding) */
void  buf_pad(t_buf *buf, char c, int n)
{
    int  i = 0;
    while (i < n)
        buf_char(buf, c), i++;
}

/* CORRECT : pointeur sur va_list */
void  conv_int(t_conv *c, va_list *ap, t_buf *buf)
{
    int n = va_arg(*ap, int);
    /* ... traite n ... */
}

/* CASSÉ : copie locale — l'appelant ne voit pas l'avance sur certains ABI */
void  conv_int_broken(t_conv *c, va_list ap, t_buf *buf)
{
    int n = va_arg(ap, int);
}

/* %08.3d avec 42 → "     042" (espaces, pas zeros !) */
if (c->precision != -1)
    c->flags &= ~FLAG_ZERO;  /* désactive le zero-padding */

void  conv_ptr(t_conv *c, va_list *ap, t_buf *buf)
{
    unsigned long long addr;
    addr = (unsigned long long)va_arg(*ap, void *);
    if (addr == 0)
    {
        apply_padding(c, buf, "(nil)", 5, 0, "", 0);
        return ;
    }
    /* ... conversion hex avec préfixe "0x" ... */
}

if (s == NULL)
{
    if (c->precision != -1 && c->precision < 6)
        len = 0;
    else
    {
        s = "(null)";
        len = 6;
    }
}

long long n = va_arg(*ap, int);
char sign = 0;

if (n < 0)
{
    sign = '-';
    n = -n;  /* OK car n est long long, pas int */
}
ull_to_base((unsigned long long)n, 10, 0, num, &num_len);

int  ft_printf(const char *format, ...)
{
    va_list ap;
    t_buf   buf;

    if (!format)
        return (-1);
    buf.len = 0;
    buf.total = 0;        /* compteur global */
    va_start(ap, format);
    process_format(format, &ap, &buf);
    va_end(ap);
    buf_flush(&buf);
    return (buf.total);     /* nombre de chars écrits */
}

/* Chaque buf_char incrémente buf.total */
void  buf_char(t_buf *buf, char c)
{
    buf->data[buf->len++] = c;
    buf->total++;          /* <-- comptage */
}

NAME        = libftprintf.a
CC          = gcc
CFLAGS      = -Wall -Wextra -Werror

SRC_DIR     = src
OBJ_DIR     = obj
INC_DIR     = includes

SRCS        = $(SRC_DIR)/ft_printf.c \
              $(SRC_DIR)/buffer.c \
              $(SRC_DIR)/utils.c \
              $(SRC_DIR)/parse.c \
              $(SRC_DIR)/conv_int.c \
  $(SRC_DIR)/conv_hex.c \
  $(SRC_DIR)/conv_text.c

OBJS        = $(SRCS:$(SRC_DIR)/%.c=$(OBJ_DIR)/%.o)

all:        $(NAME)

$(NAME):    $(OBJS)
            ar rcs $(NAME) $(OBJS)

$(OBJ_DIR)/%.o: $(SRC_DIR)/%.c | $(OBJ_DIR)
            $(CC) $(CFLAGS) -I$(INC_DIR) -c $< -o $@

$(OBJ_DIR):
            mkdir -p $(OBJ_DIR)

clean:
            rm -rf $(OBJ_DIR)

fclean:     clean
            rm -f $(NAME)

re:         fclean all

.PHONY:     all clean fclean re

# 1. Construire la bibliothèque
$ make

# 2. Compiler un programme de test qui l'utilise
$ gcc -Wall -Wextra -Iincludes -o test test.c -L. -lftprintf

# 3. Lancer
$ ./test

#define TEST(name, fmt, ...) \
    do { \
        char ft_buf[1024], std_buf[1024]; \
        int  ft_ret, std_ret; \
        /* rediriger stdout vers un pipe, capturer ft_printf */ \
        int saved = dup(1); \
        int pipefd[2]; pipe(pipefd); \
        dup2(pipefd[1], 1); \
        ft_ret = ft_printf(fmt, ##__VA_ARGS__); \
        fflush(NULL); \
        close(pipefd[1]); \
        dup2(saved, 1); \
        int ft_len = read(pipefd[0], ft_buf, sizeof ft_buf - 1); \
        ft_buf[ft_len] = '\0'; \
        /* idem avec le vrai printf */ \
        ... \
        if (strcmp(ft_buf, std_buf) == 0 && ft_ret == std_ret) \
            pass_count++; \
        else \
            printf("FAIL: %s\n  ft:  \"%s\" (%d)\n  std: \"%s\" (%d)\n", \
                   name, ft_buf, ft_ret, std_buf, std_ret); \
    } while(0)