(2)kalkulator_32bit

#program koji demonstrira kalkulator u radu sa 32-bitnim neoznacenim brojevima i tri logicke operacije (unos i ispis u heksadecimalnom brojnom sistemu, na ulazu dozvoljena i velika i mala slova). Program treba da omoguci unos prvog broja, unos logicke operacije i unos drugog broja i da na ekranu ispise rezultat ili poruku o gresci ukoliko dodje do greske (pogresan unos). Ulaz treba da je oblika: heksadecimalni_broj operacija heksadecimalni_broj pri cemu izmedju operacije i heksadecimalnog broja moze postojati jedan ili vise razmaka.
#dozvoljene operacije & (and), | (or) i ^ (xor)


.section .data

N = 100
poruka_pocetak: .ascii "Unesite string:\0"
unos: .fill N, 1, 0
greska_operand1: .ascii "Pogresan prvi operand!\0"
greska_operacija: .ascii "Pogresna operacija!\0"
greska_operand2: .ascii "Pogresan drugi operand!\0"
poruka_kraj: .ascii "Rezultat je:\0"
rezultat: .fill N, 1, 0

.section .text
.globl main
main:
    movl $4, %eax
    movl $1, %ebx
    leal poruka_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
    addl $4, %esp

    cmpl $71, %eax
    je greska_prvi_operand
    cmpl $71, %ecx
    je pogresna_operacija
    cmpl $71, %edx
    je greska_drugi_operand

    pushl %eax
    pushl %ecx
    pushl %edx
    call izvrsi
    addl $12, %esp


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

    movl $4, %eax
    movl $1, %ebx
    leal poruka_kraj, %ecx
    movl $12, %edx
    int $0x80

    movl $4, %eax
    movl $1, %ebx
    leal rezultat, %ecx
    movl $12, %edx
    int $0x80


kraj:
    movl $1, %eax
    int $0x80
greska_prvi_operand:
    movl $4, %eax
    movl $1, %ebx
    leal greska_operand1, %ecx
    movl $20, %edx
    int $0x80
    jmp kraj
greska_drugi_operand:
    movl $4, %eax
    movl $1, %ebx
    leal greska_operand2, %ecx
    movl $20, %edx
    int $0x80
    jmp kraj
pogresna_operacija:
    movl $4, %eax
    movl $1, %ebx
    leal greska_operacija, %ecx
    movl $20, %edx
    int $0x80
    jmp kraj
#===========================================================


#progran treba da konvertuje uneti string iz znakovnog oblika u interni(baza 16), vrednost ce se sacuvati u %eax

.section .text
.globl char_to_int

char_to_int:
    pushl %ebp
    movl %esp, %ebp
    subl $16, %esp  #-4()=a  -8()=op  -12()=b  -16()= indikator obrade
    pushl %esi
    pushl %edi
    pushl %ebx

    movl 8(%ebp), %esi
    movl %esi, %edi
    movl $16, %ecx
    xorl %eax, %eax #rezultat
    xorl %ebx, %ebx #karakter
    xorl %edx, %edx #greska
    movl $0, -16(%ebp) #indikator obrade
konvert:
    movb (%esi), %bl
    cmpb $' ', %bl
    jne dalje
provera_vrti:
    cmpl $0, -16(%ebp)
    je vrti1

dalje:
    cmpl $1, -16(%ebp)
    je provera_operacije

    cmpb $10, %bl
    je kraj_hexa

    cmpb $'0', %bl
    jl 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

vrti1:
    movl $1, -16(%ebp)
    movl %eax, -4(%ebp)
    movl $1, %edx  #indikator da greska nije kod prvog operanda
    incl %esi
    movb (%esi), %bl
    cmpb $' ', %bl
    je vrti1
    xorl %eax, %eax
    jmp konvert
provera_operacije:
    movl $2, -16(%ebp)
    cmpb $'^', %bl
    je vrti2
    cmpb $'&', %bl
    je vrti2
    cmpb $'|', %bl
    je vrti2
    jmp set
vrti2:
    movb %bl, -8(%ebp)
    movl $2, %edx #indikator da greska nije kod operacije
vrtic:
    incl %esi
    movb (%esi), %bl
    cmpb $' ', %bl
    je vrtic
    xorl %eax, %eax
    jmp konvert
broj:
    subb $'0', %bl
    mull %ecx
    andl %edx, %edx
    jnz set
    addl %ebx, %eax
    jc set
    incl %esi
    jmp konvert

malo_slovo:
    subb $87, %bl
    mull %ecx
    andl %edx, %edx
    jnz set
    addl %ebx, %eax
    jc set
    incl %esi
    jmp konvert

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

kraj_hexa:
    movl %eax, -12(%ebp)
    cmpl %esi, %edi
    jne kraj_pp
set:
    cmpl $0, %edx
    je set_operand1
    cmpl $1, %edx
    je set_operacija
    jmp set_operand2
set_operand1:
    movl $71, -4(%ebp)
    jmp kraj_pp
set_operacija:
    movl $71, -8(%ebp)
    jmp kraj_pp
set_operand2:
    movl $71, -12(%ebp)
    jmp kraj_pp
kraj_pp:
    movl -4(%ebp), %eax  #prvi operand
    movl -8(%ebp), %ecx  #operacija
    movl -12(%ebp), %edx #drugi operand
    popl %ebx
    popl %edi
    popl %esi
    leave
    ret


#===================================================
#program koji izvrsava datu operaciju

.section .text
.globl izvrsi
izvrsi:
    pushl %ebp
    movl %esp, %ebp
    pushl %ebx

    movl 8(%ebp), %eax #drugi operand
    movl 12(%ebp), %ebx #operacija
    movl 16(%ebp), %ecx #prvi
operacija:
    cmpb $'^', %bl
    je xor_op
    cmpb $'&', %bl
    je and_op
    cmpb $'|', %bl
    je or_op
    jmp set
xor_op:
    xorl %ecx, %eax
    jmp kraj_pp
and_op:
    andl %ecx, %eax
    jmp kraj_pp
or_op:
    orl %ecx, %eax
    jmp kraj_pp

kraj_pp:
    popl %ebx
    leave
    ret
set:
    movl $0, %edx
    jmp kraj_pp

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

#program koji vraca vrednost %eax u string

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

    movl 8(%ebp), %esi
    movl %esi, %edi
    movl 12(%ebp), %eax
    movl $16, %ecx
    xorl %ebx, %ebx
obavi:
    xorl %edx, %edx
    divl %ecx  #edx:eax / %ecx = eax, ostatak u edx
    addb $55, %dl
    movb %dl, (%esi)
    incl %esi
    andl %eax, %eax
    jnz obavi
    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 %esi
    popl %edi
    popl %ebx
    leave
    ret

    popl %ebx