task00.s

.data
    v: .space 1024
    nrop: .space 4
    op: .space 4
    nradd: .space 4
    desc: .space 4
    dim: .space 4
    formatPrint: .asciz "%ld "
    str1: .asciz "\n"
    formatPrint1: .asciz "(%d, %d)\n"
    formatPrint2: .asciz "%d: (%d, %d)\n"
    formatScan: .asciz "%d"

.text
.global main
PRINT:
    push %ebp
    mov %esp, %ebp
    push %ebx
    push %esi

    movl $1, %ecx
    movl $1, %esi
PRINT_for:
    cmp $1024, %ecx
    je PRINT_iffinal
    
    movl %ecx, %edx
    subl $1, %edx
    movb (%edi,%ecx,1), %al
    movb (%edi,%edx,1), %bl
    cmp %al, %bl
    jne PRINT_nrnou
    jmp PRINT_cont

PRINT_nrnou:
    cmp $0, %bl
    jne PRINT_nrnou_cont
    jmp PRINT_zero

PRINT_nrnou_cont:
    movl %ecx, %eax
    subl %esi, %eax
    
    push %ecx


    push %edx
    push %eax

    movb %bl, %al
    xor %ebx, %ebx
    movb %al, %bl

    push %ebx
    push $formatPrint2
    call printf 
    addl $16, %esp

    push $0
    call fflush
    addl $4, %esp

    pop %ecx

PRINT_zero:
    xor %esi, %esi

PRINT_cont:
    addl $1, %esi

    inc %ecx
    jmp PRINT_for
PRINT_iffinal:
    cmp $0, %al
    je PRINT_exit
    movl %ecx, %edx
    subl $1, %edx
    movl %ecx, %ebx
    subl %esi, %ebx

    push %edx
    push %ebx

    movb %al, %bl
    xor %eax, %eax
    movb %bl, %al

    push %eax
    push $formatPrint2
    call printf 
    addl $16, %esp
PRINT_exit:
    pop %esi
    pop %ebx
    pop %ebp
    ret
ADD:
    push %ebp
    mov %esp, %ebp
    push %ebx

    movb 8(%ebp), %bl
    movl 12(%ebp), %eax 
    movl $8, %ecx
    xor %edx, %edx
    div %ecx

    cmp $0, %edx
    je ADD_else1 
    inc %eax

ADD_else1:
    xor %edx, %edx
    xor %ecx, %ecx

    cmp $1, %eax
    je ADD_exit

ADD_for1:
    cmp $1024, %ecx
    je ADD_nuintra

    movb (%edi,%ecx,1), %bh
    cmp $0, %bh
    jne ADD_else2
    inc %edx
    jmp ADD_for1_cont
    ADD_else2:
        xor %edx, %edx
ADD_for1_cont:
    cmp %edx, %eax
    je ADD_cont

    inc %ecx
    jmp ADD_for1

ADD_cont:
    inc %ecx
    push %ecx
    sub %eax, %ecx
    mov %ecx, %edx
    pop %ecx
    push %edx
ADD_for2:
    cmp %edx, %ecx
    je ADD_afisare
    movb %bl, (%edi, %edx, 1)
    inc %edx
    jmp ADD_for2
ADD_nuintra:
    xor %eax, %eax
    movl $1, %edx
    push %eax
ADD_afisare:
    subl $1, %edx
    pop %eax
    movb %bl, %cl
    xor %ebx, %ebx
    movb %cl, %bl
    push %edx
    push %eax
    push %ebx
    push $formatPrint2
    call printf
    addl $16, %esp

ADD_exit:
    pop %ebx
    pop %ebp
    ret

GET:
    push %ebp
    movl %esp, %ebp
    push %ebx

    movb 8(%ebp), %bl
    xor %ecx, %ecx
    movl $-1, %eax
    movl $-1, %edx

GET_for:
    cmp $1024, %ecx
    je GET_cont
    movb (%edi, %ecx, 1), %bh
    cmp %bh, %bl
    je GET_if1
    jne GET_else1
GET_if1:
    cmp $-1, %eax
    je GET_if2
    jmp GET_for_cont
    GET_if2:
        movl %ecx, %eax
        jmp GET_for_cont
GET_else1:
    cmp $-1, %eax
    jne GET_else2
    jmp GET_for_cont
    GET_else2:
        sub $1, %ecx
        movl %ecx, %edx
        jmp GET_cont
GET_for_cont:
    inc %ecx
    jmp GET_for

GET_cont:
    cmp $-1, %eax
    je GET_nuexista
    cmp $-1, %edx
    je GET_if3
    jmp GET_afisare
    GET_nuexista:
        xor %eax, %eax
        xor %edx, %edx
        jmp GET_afisare
    GET_if3:
        movl $1023, %edx

GET_afisare:
    push %edx
    push %eax
    push $formatPrint1
    call printf
    addl $12, %esp

GET_exit:
    pop %ebx
    pop %ebp
    ret

DELETE:
    push %ebp
    movl %esp, %ebp
    push %ebx

    movb 8(%ebp), %bl
    xor %ecx, %ecx
DELETE_for:
    cmp $1024, %ecx
    je DELETE_exit
    
    movb (%edi, %ecx, 1), %al
    cmp %al, %bl
    je DELETE_elem
    jmp DELETE_for_cont

DELETE_elem:
    movb $0, (%edi, %ecx, 1)

DELETE_for_cont:
    inc %ecx
    jmp DELETE_for

DELETE_exit:
    call PRINT

    pop %ebx
    pop %ebp
    ret

DEFRAG:
    push %ebp
    movl %esp, %ebp
    push %ebx
    

    xor %ecx, %ecx
    xor %edx, %edx

DEFRAG_for:
    cmp $1024, %ecx
    je DEFRAG_cont

    movb (%edi, %ecx, 1), %bl
    cmp $0, %bl
    jne DEFRAG_for_if
    jmp DEFRAG_for_cont

DEFRAG_for_if:
    movb (%edi, %ecx, 1), %bl
    movb %bl, (%edi, %edx, 1)
    inc %edx

DEFRAG_for_cont:
    inc %ecx
    jmp DEFRAG_for

DEFRAG_cont:
    movl %edx, %ecx

DEFRAG_forzero:
    cmp $1024, %ecx
    je DEFRAG_exit

    movb $0, (%edi, %ecx, 1)

    inc %ecx
    jmp DEFRAG_forzero

DEFRAG_exit:
    call PRINT

    pop %ebx
    pop %ebp
    ret
main:
    lea v, %edi

    push $nrop 
    push $formatScan
    call scanf
    addl $8, %esp

    xor %ecx, %ecx
for:
    cmp %ecx, nrop
    je exit

    push %ecx
    push $op 
    push $formatScan
    call scanf 
    addl $8, %esp

    cmpl $1, op
    je if_add
    cmpl $2, op 
    je if_get
    cmpl $3, op
    je if_delete
    cmpl $4, op
    je if_defrag
    // jmp caz op invalid?
    
if_add:
    push $nradd
    push $formatScan
    call scanf 
    addl $8, %esp


    xor %ebx, %ebx

if_add_for:
    cmp %ebx, nradd
    je for_cont

    push $desc 
    push $formatScan
    call scanf
    addl $8, %esp

    push $dim
    push $formatScan
    call scanf
    addl $8, %esp

    push dim
    push desc
    call ADD 
    addl $8, %esp

    inc %ebx
    jmp if_add_for

if_get:
    push $desc 
    push $formatScan
    call scanf
    addl $8, %esp

    push desc
    call GET 
    addl $4, %esp 

    jmp for_cont

if_delete:
    push $desc 
    push $formatScan
    call scanf
    addl $8, %esp

    push desc 
    call DELETE 
    addl $4, %esp

    jmp for_cont

if_defrag:
    call DEFRAG

for_cont:
//    push $str1
//    call printf
//    addl $4, %esp 
    
    pop %ecx
    inc %ecx
    jmp for

exit:
//    push $str1
 //   call printf
 //   addl $4, %esp 
    push $0
    call fflush
    addl $4, %esp

    movl $1, %eax
    xor %ebx, %ebx
    int $0x80