checksum

#program koji u zavisnosti od znaka operacije racuna kontrolnu sumu (c) unetih brojnih vrednosti. Prvi operand je heksadecimalni(dozvoljena mala slova i velika), drugi je oktalni, izlaz je binarni.
#ukoliko dodje do pogresnog unosa ispisati odgovarajucu poruku. Korektan unos operacije je karakter 'c'

.section .data
N = 35
pocetak: .ascii "Unesite izraz:\0"
unos: .fill N,1,0
kraj_string: .ascii "Rezultat je:\0"
rezultat: .fill N,1,0
greska_operand1:  .ascii "Pogresan prvi operand!\0"
greska_operacija: .ascii "Pogresna operacija!\0"
greska_operand2:  .ascii "Pogresan drugi operand!\0"
prazan_string: .ascii "Uneli ste prazan string!\0"
.section .text
.globl main
main:
    movl $4, %eax
    movl $1, %ebx
    leal pocetak, %ecx
    movl $20, %edx
    int $0x80

    movl $3, %eax
    movl $0, %ebx
    leal unos, %ecx
    movl $N, %edx
    int $0x80

    xorl %eax, %eax
    leal unos, %eax
    pushl %eax
    call char_to_int
    cmpl $101, %eax
    je greska_string
    cmpl $71, %eax
    je greska_operanda1
    cmpl $71, %ecx
    je greska_operacije
    cmpl $71, %edx
    je greska_operanda2
    addl $4, %esp

    pushl %eax
    pushl %edx
    call checksum
    addl $8, %esp


    xorl %ebx, %ebx
    leal rezultat, %ebx
    pushl %ebx
    pushl %eax
    call int_to_char
    addl $8, %esp

    movl $4, %eax
    movl $1, %ebx
    leal kraj_string, %ecx
    movl $N, %edx
    int $0x80




kraj:
    movl $1, %eax
    int $0x80

greska_operanda1:
    movl $4, %eax
    movl $1, %ebx
    leal greska_operand1, %ecx
    movl $22, %edx
    int $0x80
    jmp kraj
greska_operacije:
    movl $4, %eax
    movl $1, %ebx
    leal greska_operacija, %ecx
    movl $19, %edx
    int $0x80
    jmp kraj
greska_operanda2:
    movl $4, %eax
    movl $1, %ebx
    leal greska_operand2, %ecx
    movl $23, %edx
    int $0x80
    jmp kraj
greska_string:
    movl $4, %eax
    movl $1, %ebx
    leal prazan_string, %ecx
    movl $24, %edx
    int $0x80
    jmp kraj
#==============================================================

#potprogram koji konvertuje uneti string, i kao vrednost daje interni oblik u registar eax
#konvertuje heksadecimalni, prepoznaje karakter, konvertuje binarni
.section .text
.globl char_to_int
char_to_int:
    pushl %ebp
    movl %esp, %ebp
    subl $16, %esp   # -4(a) -8(operacija) -12(operand) -16(greska)
    pushl %esi
    pushl %edi
    pushl %ebx

    movl 8(%ebp), %esi
    movl %esi, %edi # zbog poredjenja adresa
    xorl %eax, %eax #rezultat
    xorl %ebx, %ebx #karakter
    xorl %edx, %edx #indikator da je upisan prvi operand
    movl $0, -16(%ebp) #greska
    movl $16, %ecx
konvert:
    movb (%esi), %bl
    cmpb $' ', %bl
    je upisi_a
    cmpb $10, %bl
    je kraj_string

provera_operacije:
    cmpl $1, %edx
    jne dalje
    cmpb $99, %bl
    jne set_op
    movb %bl, -8(%ebp)
do_oktalnog:
    incl %esi
    movb (%esi), %bl
    cmpb $' ',  %bl
    jne nadji_oktalni
    jmp do_oktalnog
dalje:
    cmpb $'0', %bl
    je set
    cmpb $'9', %bl
    jle broj
    cmpb $'A', %bl
    jl set
    cmpb $'F', %bl
    jle veliko_slovo
    cmpb $'a', %bl
    jl set
    cmpb $'f', %bl
    jle malo_slovo
set:
    movl $71, -4(%ebp)
    jmp kraj_pp
set_b:
    movl $71, -12(%ebp)
    jmp kraj_pp
set_op:
    movl $71, -8(%ebp)
    jmp kraj_pp
setup:
    movl $101, -16(%ebp)
    jmp kraj_ppp
nadji_oktalni:
    xorl %eax, %eax
    movl $8, %ecx
nastavi_oktalni:
    cmpb $10, %bl
    jne dalje_okt
    movl %eax, -12(%ebp)
    jmp kraj_pp
dalje_okt:
    subb $'0', %bl
    jc set_b
    cmpb $8, %bl
    ja set_b
    mull %ecx
    andl %edx, %edx
    jnz set_b
    addl %ebx, %eax
    jc set_b
    incl %esi
    movb (%esi), %bl
    jmp nastavi_oktalni

kraj_string:
    cmpl %esi, %edi
    jne kraj_pp
    jmp setup


broj:
    subb $'0', %bl
    mull %ecx
    andl %edx, %edx
    jnz set
    addl %ebx, %eax
    jc set
do_operacije:
    incl %esi
    movb (%esi), %bl
    jmp konvert
upisi_a:
    movl %eax, -4(%ebp) #upis prvog operanda
    movl $1, %edx
    incl %esi
    jmp konvert
malo_slovo:
    subb $87, %bl
    mull %ecx
    andl %edx, %edx
    jnz set
    addl %ebx, %eax
    jc set
    jmp do_operacije

veliko_slovo:
    subb $55, %bl
    mull %ecx
    andl %edx, %edx
    jnz set
    addl %ebx, %eax
    jc set
    jmp do_operacije

kraj_pp:
    movl -4(%ebp), %eax
    movl -8(%ebp), %ecx
    movl -12(%ebp), %edx

    popl %ebx
    popl %edi
    popl %esi
    leave
    ret
kraj_ppp:
    movl -16(%ebp), %eax
    popl %ebx
    popl %edi
    popl %esi
    leave
    ret

#==============================================================

#potprogram koji promalazi kontrolnu sumu dva interna broja

.section .text
.globl checksum
checksum:
    pushl %ebp
    movl %esp, %ebp
    pushl %esi
    pushl %edi
    pushl %edx

    movl 8(%ebp), %ebx #drugi operand
    movl 12(%ebp), %ecx #prvi operand
    xorl %eax, %eax   #kontrolna suma
    movl $1, %edx    #maska

sledeci_element:
    xorl %esi, %esi #brojac jedinica

kontrola1:
    andl %edx, %ecx
    jz kontrola2
    incl %esi
kontrola2:
    andl %edx, %ebx
    jz suma
    incl %esi
suma:
    shrl $1, %esi
    rcrl $1, %eax
    shll $1, %edx
    jnc sledeci_element

kraj_pp:
    popl %edx
    popl %edi
    popl %esi
    leave
    ret
#===================================================

#potprogram koji konvertuje dobijenu kontrolnu sumu iz internog u znakovni oblik(binarna pretstava)

.section .text
.globl int_to_char
int_to_char:
    pushl %ebp
    movl %esp, %ebp
    pushl %esi
    pushl %edi
    pushl %ebx

    movl 8(%ebp), %eax #vrednos koja se konvertuje
    movl 12(%ebp), %esi  #adresa rezultujuceg stringa
    movl %esi, %edi
konvert:
    shrl $1, %eax
    rclb $1, %bl
    andb $1, %bl
    addb $'0', %bl
    movb %bl, (%esi)
    incl %esi
    andl %eax, %eax
    jnz konvert
    movb $0, (%esi)
    decl %esi
obrni:
    cmpl %esi, %edi
    jae kraj_pp
    movb (%edi), %ah
    movb (%esi), %al
    movb %ah, (%esi)
    movb %al, (%edi)
    incl %edi
    decl %esi
    jmp obrni
kraj_pp:
    popl %ebx
    popl %edi
    popl %esi
    leave
    ret