libasm

section .text
global ft_strlen

ft_strlen:
    xor     rax, rax         ; rax = 0 (compteur)
.loop:
    cmp     byte [rdi + rax], 0   ; si char == '\0'
    je      .done
    inc     rax
    jmp     .loop
.done:
    ret                      ; retourne rax = longueur

ft_strcpy:
    mov     rax, rdi         ; save dst (return value)
.loop:
    mov     cl, byte [rsi]   ; load src byte
    mov     byte [rdi], cl   ; store to dst
    cmp     cl, 0            ; null terminator?
    je      .done
    inc     rdi
    inc     rsi
    jmp     .loop
.done:
    ret

ft_strcmp:
.loop:
    mov     cl, byte [rdi]   ; s1[i]
    mov     dl, byte [rsi]   ; s2[i]
    cmp     cl, dl
    jne     .diff
    cmp     cl, 0            ; both null?
    je      .equal
    inc     rdi
    inc     rsi
    jmp     .loop
.diff:
    movzx   rax, cl          ; zero-extend s1[i]
    movzx   rcx, dl          ; zero-extend s2[i]
    sub     rax, rcx         ; return s1[i] - s2[i]
    ret
.equal:
    xor     rax, rax         ; return 0
    ret

section .text
global ft_write
extern __errno_location

ft_write:
    mov     rax, 1           ; syscall write = 1
    syscall
    cmp     rax, 0
    jge     .success         ; succès si >= 0
    neg     rax              ; -errno → +errno
    push    rax              ; save errno value
    call    __errno_location ; rax = &errno
    pop     rcx              ; restore errno value
    mov     dword [rax], ecx ; *errno = errno_value
    mov     rax, -1          ; return -1
.success:
    ret

ft_read:
    mov     rax, 0           ; syscall read = 0
    syscall
    cmp     rax, 0
    jge     .success
    neg     rax              ; -errno → +errno
    push    rax
    call    __errno_location
    pop     rcx
    mov     dword [rax], ecx
    mov     rax, -1
.success:
    ret

ft_strdup:
    push    rdi              ; save src (rsi will be clobbered by malloc)
    mov     rsi, rdi
    xor     rcx, rcx
.strlen_loop:
    cmp     byte [rsi + rcx], 0
    je      .strlen_done
    inc     rcx
    jmp     .strlen_loop
.strlen_done:
    lea     rdi, [rcx + 1]   ; malloc(len + 1)
    call    malloc
    pop     rsi              ; restore src into rsi
    test    rax, rax         ; malloc failed?
    je      .fail
    mov     rdi, rax         ; rdi = dst
.copy_loop:
    mov     cl, byte [rsi]
    mov     byte [rdi], cl
    cmp     cl, 0
    je      .copy_done
    inc     rsi
    inc     rdi
    jmp     .copy_loop
.copy_done:
    ret                     ; return dst (rax)
.fail:
    ret                     ; return NULL

typedef struct  s_list
{
    void        *data;      /* offset 0  — 8 bytes */
    struct s_list *next;    /* offset 8  — 8 bytes */
}               t_list;     /* total: 16 bytes */

.check_dup_i:
    cmp     rcx, rbx             ; test de borne de boucle
    jge     .check_dup_done
    mov     al, byte [r13 + rcx]
    cmp     al, '+'              ; + interdit
    je      .ret_zero
    cmp     al, '-'              ; - interdit
    je      .ret_zero
    cmp     al, ' '              ; space interdit
    je      .ret_zero
    cmp     al, 9                ; si < 9 → valide (control chars)
    jl      .check_next
    cmp     al, 13               ; si 9-13 → interdit (whitespace)
    jle     .ret_zero
.check_next:                     ; vérifier doublons...

ft_list_push_front:
    push    rdi              ; save begin_list
    push    rsi              ; save data
    mov     rdi, 16          ; malloc(16) = sizeof(t_list)
    call    malloc
    pop     rsi              ; rsi = data
    pop     rdi              ; rdi = begin_list
    test    rax, rax         ; malloc failed?
    je      .fail
    mov     [rax], rsi       ; new->data = data
    mov     rcx, [rdi]       ; old head
    mov     [rax + 8], rcx   ; new->next = old head
    mov     [rdi], rax       ; *begin_list = new
.fail:
    ret

ft_list_size:
    xor     rax, rax         ; counter = 0
.loop:
    test    rdi, rdi         ; if (list == NULL)
    je      .done
    inc     rax
    mov     rdi, [rdi + 8]   ; list = list->next
    jmp     .loop
.done:
    ret

NAME        = libasm.a
NASM        = nasm
NASMFLAGS   = -f elf64

SRCS        = $(SRCS_DIR)/ft_strlen.s \\
              $(SRCS_DIR)/ft_strcpy.s \\
              $(SRCS_DIR)/ft_strcmp.s \\
              $(SRCS_DIR)/ft_write.s \\
              $(SRCS_DIR)/ft_read.s \\
              $(SRCS_DIR)/ft_strdup.s

BONUS_SRCS  = $(SRCS_DIR)/ft_atoi_base.s \\
              $(SRCS_DIR)/ft_list_push_front.s \\
              $(SRCS_DIR)/ft_list_size.s \\
              $(SRCS_DIR)/ft_list_sort.s \\
              $(SRCS_DIR)/ft_list_remove_if.s

# Compile .s → .o avec nasm
%.o:        %.s $(HEADERS)
            $(NASM) $(NASMFLAGS) $< -o $@

# Archive → libasm.a
$(NAME):    $(OBJS) $(HEADERS)
            ar rcs $(NAME) $(OBJS)

# Bonus: ajoute les .o bonus à l'archive
bonus:      $(OBJS) $(BONUS_OBJS) $(HEADERS)
            ar rcs $(NAME) $(OBJS) $(BONUS_OBJS)