(1)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 = 50
poruka1: .ascii "Unesite izraz:\0"
unos: .fill N,1,0
greska1: .ascii "Pogresan prvi operand!\0"
greska2: .ascii "Pogresan drugi operand!\0"
greska3: .ascii "Pogresna operacija!\0"
poruka2: .ascii "Rezultat je:\0"
rezultat: .fill N,1,0
.section .text
.globl main
main:

    movl $4, %eax
    movl $1, %ebx
    leal poruka1, %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 konvert_string

    cmpl $0, %edx
    je greska_operacija
    cmpl $0, %eax
    je greska_operanda1
    cmpl $0, %ecx
    je greska_operanda2
    addl $4, %esp



    pushl %ecx    #drugi operand
    pushl %edx     #operacija
    pushl %eax     #prvi operand
    call obavi
    movl %eax, %edx
    addl $12, %esp


    xorl %ebx, %ebx
    leal rezultat, %ebx
    pushl %edx
    pushl %ebx
    call u_interni
    addl $8, %esp


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



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

greska_operacija:
    movl $4, %eax
    movl $1, %ebx
    leal greska3, %ecx
    movl $N, %edx
    int $0x80
    jmp kraj
greska_operanda1:
    movl $4, %eax
    movl $1, %ebx
    leal greska1, %ecx
    movl $N, %edx
    int $0x80
    jmp kraj
greska_operanda2:
    movl $4, %eax
    movl $1, %ebx
    leal greska2, %ecx
    movl $N, %edx
    int $0x80
    jmp kraj

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





#program koji konvertuje string iz znakovnog u interni(baza16)



.section .text
.globl konvert_string
konvert_string:
    pushl %ebp
    movl %esp, %ebp
    subl $12,%esp// -4 b1, -8 op -12 b2
    pushl %esi
    pushl %edi
    pushl %ebx


    movl 8(%ebp), %esi #adresa stringa
    movl %esi, %edi
    xorl %eax, %eax
    movl $16, %ecx
nadji_broj:
    movb (%esi), %bl
    cmpb $' ', %bl
    je dalje
    cmpb $10, %bl
    je kraj_heksa

    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
    cmpb $0, %dl
    jne set2
set:
    xorl %edx, %edx
    movb $0, -4(%ebp)
    jmp kraj_pp
set2:
    movb $0, -12(%ebp)
    jmp kraj_pp
dalje:
    movl %eax, -4(%ebp)  #prvi broj
    xorl %eax, %eax
nadji_operaciju:
    incl %esi
    movb (%esi), %bl
    cmpb $' ', %bl
    je nadji_operaciju
    cmpb $'^', %bl
    je nadji_xor
    cmpb $'&', %bl
    je nadji_and
    cmpb $'|', %bl
    je nadji_ili
set_op:
    movb $0, -8(%ebp)
    jmp kraj_pp

veliko_slovo:
    subb $55, %bl
    mull %ecx
    addl %ebx, %eax
    incl %esi
    jmp nadji_broj

malo_slovo:
    subb $87, %bl
    mull %ecx
    addl %ebx, %eax
    incl %esi
    jmp nadji_broj
broj:
    subb $'0', %bl
    mull %ecx
    addl %ebx, %eax
    incl %esi
    jmp nadji_broj

nadji_xor:
    movb $'^',  -8(%ebp)
    jmp nadji_drugi_broj
nadji_and:
    movb $'&', -8(%ebp)
    jmp nadji_drugi_broj
nadji_ili:
    movb $'|', -8(%ebp)

nadji_drugi_broj:
    incl %esi
    movb (%esi), %bl
    cmpb $' ', %bl
    je nadji_drugi_broj
    jmp nadji_broj

kraj_heksa:
    movl %eax, -12(%ebp)  #drugi broj
        cmpl %edi, %esi #'\0' na poÄŤetku stringa?
        je set

kraj_pp:
    movl -4(%ebp), %eax #prvi broj
    movl -8(%ebp), %edx #operacija
    movl -12(%ebp), %ecx #drugi broj
        popl %ebx
        popl %edi
        popl %esi
        leave
        ret

#============================================================
#potprogram koji obavlja operaciju

.section .text
.globl obavi
obavi:
    pushl %ebp
    movl %esp, %ebp
    subl $4, %esp
    pushl %ebx
    pushl %esi
    pushl %edi

    movl 8(%ebp), %eax #prvi operand
    movl 12(%ebp), %ebx #operacija
    movl 16(%ebp), %ecx #drugi operand

provera_operacije:
    cmpb $'&', %bl
    je and_op
    cmpb $'|', %bl
    je or_op
    cmpb $'^', %bl
    je xor_op
and_op:
    andl %ecx, %eax
    jmp kraj_pp
or_op:
    orl %ecx, %eax
    jmp kraj_pp
xor_op:
    xorl %ecx, %eax
kraj_pp:
    popl %edi
    popl %esi
    popl %ebx
    leave
    ret

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

#potprogram koji vraca rezultat iz internog u znakovni

.section .text
.globl u_interni

u_interni:
    pushl %ebp
    movl %esp, %ebp
    pushl %esi
    pushl %edi
    pushl %ebx

    movl 8(%ebp), %esi   #adresa rezultujuceg stringa
    movl %esi, %edi
    movl 12(%ebp), %eax  #broj koji se konvertuje
    movl $16, %ecx
heksa_cifra:
        xorl %edx, %edx
        divl %ecx
        cmpb $9, %dl
    ja slovo
    addb $'0', %dl
        movb %dl, (%esi)
        incl %esi
        andl %eax, %eax
        jnz heksa_cifra
        movb $0, (%esi)
        decl %esi
obrni:
    cmpl %esi, %edi
    jae kraj
    movb (%esi), %ah
    movb (%edi), %al
    movb %al, (%esi)
    movb %ah, (%edi)
    decl %esi
    incl %edi
    jmp obrni

slovo:
    addb $55, %dl
    movb %dl, (%esi)
    incl %esi
    andl %eax, %eax
    jmp heksa_cifra
    movb $0, (%esi)
    decl %esi
    jmp obrni

kraj:
    popl %ebx
    popl %esi
    popl %edi
    leave
    ret