SYS_READ = 0
SYS_WRITE = 1
SYS_OPEN = 2
SYS_CLOSE = 3
SYS_EXIT = 60

.bss
.comm input_buffer 1024
.comm input_length 8
.comm number1 1024
.comm number2 1024
.comm answer 1025
.comm itoa_buffer 4096
.comm out_buffer 4096
.comm fdcopy 8
.data
num1_txt:
.asciz "number1.txt"
num2_txt:
.asciz "number2.txt"
answ_txt:
.asciz "answer.txt"
.text
.globl _start

_start:
        mov $SYS_OPEN, %rax
        mov $num1_txt, %rdi
        mov $0, %rsi
        mov $0, %rdx
        syscall                 #otworz plik "number1.txt"
        cmp $0, %rax            #zero w rax = blad przy otworzeniu pliku
        je fail                 # idz do fail
                                #jezeli jestesmy tutaj
                                #to plik sie otworzyl

        mov %rax, fdcopy

        mov $SYS_READ, %rax
        mov fdcopy, %rdi
        mov $input_buffer,%rsi
        mov $1023, %rdx
        syscall                 # przeczytaj 1023 max bajtow z pliku do buffora input_buffer
                                # w rax jest dlugosc stringa

        mov %rax, input_length
        mov $number1, %rdi
        call convert_ascii_to_binary_number
after_convo:
        mov $SYS_CLOSE, %rax
        mov fdcopy, %rdi
        syscall                 #zamknij plik

                                #otworz plik z number2
        mov $SYS_OPEN, %rax
        mov $num2_txt, %rdi
        mov $0, %rsi
        mov $0, %rdx
        syscall                 #otworz plik "number1.txt"
        cmp $0, %rax            #zero w rax = blad przy otworzeniu pliku
        je fail                 # idz do fail
                                #jezeli jestesmy tutaj
                                #to plik sie otworzyl

        mov %rax, fdcopy

        mov $SYS_READ, %rax
        mov fdcopy, %rdi
        mov $input_buffer,%rsi
        mov $1023, %rdx
        syscall                 # przeczytaj 1023 max bajtow z pliku do buffora input_buffer
                                # w rax jest dlugosc stringa
        mov %rax, input_length
        mov $number2, %rdi
        call convert_ascii_to_binary_number

        mov $SYS_CLOSE, %rax
        mov fdcopy, %rdi
        syscall                 #zamknij plik

        call adder
        mov answer, %rsi
        call big_number_to_ascii
        mov $SYS_OPEN, %rax
        mov $answ_txt, %rdi
        mov $102, %rsi            #flags 2 = write and read, 100 = create if not exist
        mov $0, %rdx
        syscall
brk:
        cmp $0, %rax
        je fail

        mov %rax, fdcopy

        mov $SYS_WRITE, %rax
        mov fdcopy, %rdi
        mov $out_buffer, %rsi
        mov $1023, %rdx
        syscall                 #wypisz do konsolii (1 = stdout)

        mov $SYS_CLOSE, %rax
        mov fdcopy, %rdi
        syscall                 #zamknij plik



fail:
        mov $SYS_EXIT, %rax
        mov $999, %rdi
        syscall
################################ CONVERTER #################################
############################################################################
############################################################################
############################################################################
############################################################################
convert_ascii_to_binary_number: # w rax jest pointer do buffora gdzie mamy zapisac liczbe
        mov input_length, %rcx
        sub $3, %rcx

        xor %rsi, %rsi          # zeruj counter na output

loop:
        movb input_buffer(%rcx), %al
        cmp $'0', %al
        jl not_a_number
        cmp $'9', %al
        jg not_a_number
                                #jezeli jestesmy tutaj, to al zawiera cyfre
        sub $'0', %al
        jmp we_got_a_digit
not_a_number:big_number_to_ascii
        cmp $big_number_to_ascii
        jl fabig_number_to_ascii
        cmp $big_number_to_ascii
        jg fabig_number_to_ascii
             big_number_to_ascii
        sub $big_number_to_ascii

we_got_a_digit:
        shl $4, %al             #przesun al o 4 bity w lewo (0xa = 0xa0)
        mov %al, %bl
        inc %rcx

        movb input_buffer(%rcx), %al
        cmp $'0', %al
        jl not_a_number2
        cmp $'9', %al
        jg not_a_number2
                                #jezeli jestesmy tutaj, to al zawiera cyfre
        sub $'0', %al
        jmp we_got_a_digit2
not_a_number2:
        cmp $'a', %al
        jl fail
        cmp $'f', %al
        jg fail
                                #jezeli jestesmy tutaj, to al zawiera literke (a-f)
        sub $('a' - 10), %al

we_got_a_digit2:
        add %al, %bl
        movb %bl, (%rdi, %rsi)  # przenies bl do %rdi[%rsi]
        inc %rsi
        sub $3, %rcx
        cmp $0, %rcx
        jge loop
end_of_conversion:
        ret


################################ DODAWANIE #################################
############################################################################
############################################################################
############################################################################
############################################################################

adder:
        xor %rax, %rax          # zeruj counter
        mov $1024/8, %rbx       # ile razy chcemy dodawac bajty ? (max rozmiar 1024 bajty. Dodaje co 8 bajtow, wiec ilosc petli = 1024/8)
        xor %rcx, %rcx          # zeruj counter
        clc                     # wyzeruj carry flag (flaga przeniesienia)
        pushf
loop1:
        popf
        mov number1(,%rax, 8), %rsi
        mov number2(,%rax, 8), %rdi
        adc %rsi, %rdi          #adc = rsi + rdi + carry
        mov %rdi, answer(,%rax, 8)
        pushf                   # wrzuc flagi (miedzy innymi carry)
        dec %rbx                # jezeli dec sprawie, ze rbx bedzie rowny 0, to ustawi flage 'zero'
        jnz loop1               # jump if not zero, czyli rob petle jezeli rbx nie jest zero
        popf
        ret


big_number_to_ascii:
                                # teraz zamienay liczbe na text w bazie 8kowej
        xor %rcx, %rcx # zerujemy licznik
        mov %rsi, %rax # dzielimy liczbe (div wymaga rax)
        mov $8, %rbx    # wrzuc 7 do rbx, bo chcemy dzielic przez 7

loopx:
        xor %rdx, %rdx # zeruj rdx
        div %rbx        #rdx:rax / 7 (rbx)

        add $'0', %rdx # dodaj ascii zero do reszty z dzielenia
        mov %dl, itoa_buffer(%rcx) #wrzuc cyfre ascii do buffora
        inc %ecx                    #dodaj +1 do licznika buffora
        cmp $0, %rax                #jezeli wynik dzielenia == 0
        jne loopx                   # to koniec petli
po_itoa:
        dec %rcx                    #poprzednia funkcja zostawia w ecx dlugosc
                                    # stringa
        xor %rsi, %rsi              #zeruj licznik
loop3:
        mov itoa_buffer(%rcx), %al  #czytaj bajt z buffora
        mov %al, out_buffer(%rsi)   #zapisz do nowego buffora
        inc %rsi                    #+1 nowy buffor
        dec %rcx                    #-1 stary buffor
        cmp $0, %rcx
        jge loop3

        ret