xtern malloc

section .text

global crear
global longitud
global insertar_primero
global insertar_ultimo
global insertar_posicion
global eliminar_id
global eliminar_posicion
global destruir
global ordenar
global imprimir

%define off_lista_primero 0
%define off_lista_ultimo 4
%define off_lista_longitud 8
%define lista [ebp + 8]
%define nombre [ebp + 12]
%define id [ebp + 16]
%define peso [ebp + 18]

crear:
    ;list *crear();

    push ebp ;convención c
    mov ebp, esp ;convención c
    push edi ;convención c
    push esi ;convención c
    push ebx ;convención c

    push dword 12 ;tamaño en bytes de la "lista"
    call malloc
    add esp, 4
    mov ebx, 0 ;preparo el 0.

    ;longitud 0, primero y último apuntan a null...

    mov [eax + off_lista_primero], ebx
    mov [eax + off_lista_ultimo], ebx
    mov [eax + off_lista_longitud], bx


    pop ebx ;convención c
    pop esi ;convención c
    pop edi ;convención c
    pop ebp ;convención c
    ret
;//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
longitud:
    ;unsigned int longitud(list *lista);

    push ebp ;convención c
    mov ebp, esp ;convención c
    push edi ;convención c
    push esi ;convención c
    push ebx ;convención c

    mov esi, lista
    mov eax, [esi + 8] ; pongo en eax el valor de la longitud


    pop ebx ;convención c
    pop esi ;convención c
    pop edi ;convención c
    pop ebp ;convención c
    ret
;//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
insertar_primero:
    ;void insertar_primero(list *lista, char *nombre, short id, float peso);

    push ebp ;convención c
    mov ebp, esp ;convención c
    push edi ;convención c
    push esi ;convención c
    push ebx ;convención c

    push dword 18 ; pido 18 bytes para un nodo nuevo
    call malloc
    add esp, 4

    mov esi, lista ;puntero a la lista pasada como parámetro
    mov edi, [esi] ; me guardo el puntero al ex-primer nodo de la lista

    ;inicializo las variables del nuevo primer nodo
    mov bx, id
    mov [eax], bx
    mov ebx, nombre
    mov [eax + 2], ebx
    mov ebx, peso
    mov [eax + 6], ebx
    mov [eax + 10], edi ; cargo el puntero del ex primer nodo en "siguiente" del nuevo primer nodo
    mov dword [eax + 14], 0 ;el anterior del nuevo primer nodo debe ser NULL

    mov edx, eax ;salvo el puntero al nuevo nodo para preguntar por longitud
    push dword lista ; voy a obtener la longitud para separar en casos
    call longitud
    add esp, 4

    cmp eax, 0
    je ins_pri_vacia

    mov [edi + 14], edx ; el anterior del ex-primer nodo debe apuntar al nuevo primer nodo
    mov [esi + off_lista_primero], edx ; ahora el primer nodo de la lista es el nuevo
    mov ebx, [edi + off_lista_longitud] ; longitud++
    inc ebx
    mov [esi + off_lista_longitud], ebx
    jmp ins_pri_fin

ins_pri_vacia:
    mov [esi + off_lista_primero], edx ; ahora el primer nodo de la lista es el nuevo
    mov [esi + off_lista_ultimo], edx ; ahora el primer nodo de la lista es el nuevo
    mov ebx, [esi + off_lista_longitud] ; longitud++
    inc ebx
    mov [esi + off_lista_longitud], ebx
ins_pri_fin:
    pop ebx ;convención c
    pop esi ;convención c
    pop edi ;convención c
    pop ebp ;convención c
    ret

;//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
insertar_ultimo:
    ;void insertar_ultimo(list *lista, char *nombre, short id, float peso);

    push ebp ;convención c
    mov ebp, esp ;convención c
    push edi ;convención c
    push esi ;convención c
    push ebx ;convención c

    push dword 18 ; pido 18 bytes para un nodo nuevo
    call malloc
    add esp, 4

    mov esi, lista ;puntero a la lista pasada como parámetro
    mov edi, [esi + 4] ; me guardo el puntero al ex-último nodo de la lista

    ;inicializo las variables del nuevo último nodo
    mov bx, id
    mov [eax], bx
    mov ebx, nombre
    mov [eax + 2], ebx
    mov ebx, peso
    mov [eax + 6], ebx
    mov dword [eax + 10], 0 ; el nuevo último tiene su siguiente en null
    mov [eax + 14], edi ;el anterior del nuevo ahora apunta al ex-último

    mov edx, eax ;salvo el puntero al nuevo nodo para preguntar por longitud
    push dword lista ; voy a obtener la longitud para separar en casos
    call longitud
    add esp, 4

    cmp eax, 0
    je ins_ult_vacia

    mov [edi + 10], eax ; el siguiente d el ex-primer nodo debe apuntar al nuevo primer nodo

    mov [esi + off_lista_ultimo], edx ; ahora el último nodo de la lista es el nuevo
    mov ebx, [edi + off_lista_longitud] ; longitud++
    inc ebx
    mov [esi + off_lista_longitud], ebx
    jmp ins_ult_fin

ins_ult_vacia:
    mov [esi + off_lista_primero], edx ; ahora el primer nodo de la lista es el nuevo
    mov [esi + off_lista_ultimo], edx ; ahora el ultimo nodo de la lista es el nuevo
    mov ebx, [esi + off_lista_longitud] ; longitud++
    inc ebx
    mov [esi + off_lista_longitud], ebx
ins_ult_fin:

    pop ebx ;convención c
    pop esi ;convención c
    pop edi ;convención c
    pop ebp ;convención c
    ret

;//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
%define posicion [ebp + 22]

insertar_posicion:
    ;void insertar_posicion(list *lista, char *nombre, short id, float peso, unsigned int posicion);

    push ebp ;convención c
    mov ebp, esp ;convención c
    push edi ;convención c
    push esi ;convención c
    push ebx ;convención c

    push dword lista ; voy a obtener la longitud para separar en casos
    call longitud
    add esp, 4

    mov ebx, posicion
    cmp ebx, 0
    je subrutina_ins_primero ;este es el caso en que inserto al principio
    cmp ebx, eax
    je subrutina_ins_ultimo ;este es el caso en el que inserto al final
    ja fin_insertar_posicion ;aca posicion > longitud de la lista, no hago nada

    ;acá es el caso en el que tengo que insertar el nodo en medio de otros 2...

    dec eax ; decremento porque sé que como mínimo, inserto en la posicion 1
    mov ecx, lista ; puntero a la lista pasada como parámetro
    mov edi, [ecx] ;puntero a nodo izquierdo
    mov esi, [edi + 10] ;puntero a nodo derecho
ciclo_insertar:
    cmp eax, 0
    je terminar_insercion
    mov edi, esi
    mov esi, [esi + 10]
    dec eax
    jmp ciclo_insertar

terminar_insercion:
    push dword 18
    call malloc
    add esp, 4

    mov bx, id
    mov [eax], bx
    mov ebx, nombre
    mov [eax + 2], ebx
    mov ebx, peso
    mov [eax + 6], ebx
    mov [eax + 10], esi
    mov [eax + 14], edi

    mov ebx, [ecx + off_lista_longitud] ; longitud++
    inc ebx
    mov [ecx + off_lista_longitud], ebx

    jmp fin_insertar_posicion

subrutina_ins_primero:
    push dword peso
    push word id
    push dword nombre
    push dword lista
    call insertar_primero
    add esp, 14
    jmp fin_insertar_posicion

subrutina_ins_ultimo:
    push dword peso
    push word id
    push dword nombre
    push dword lista
    call insertar_ultimo
    add esp, 14
    jmp fin_insertar_posicion

fin_insertar_posicion:
    pop ebx ;convención c
    pop esi ;convención c
    pop edi ;convención c
    pop ebp ;convención c
    ret
;//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
eliminar_id:
    ret
eliminar_posicion:
    ret
destruir:
    ret
ordenar:
    ret
imprimir:
    ret