konvert1

#program koji pretvara decimalni i heksadecimalni broj u interni oblik, i primenjuje operaciju u zavisnosti od unetog karaktera operacije i vraca string u heksadecimanom formatu.(kod heksadecimalnog unosa dozvoljena mala i velika slova, dozvoljene operacije ^, &,|) Ako je uneta pogresna operacija, negirati oba broja, sabrati ih, i kao izlaz vratiti string u oktalnom formatu. Za svaku aktivnost odstampati odgovarajucu poruku.

.section .data
N = 50
pocetna_poruka:  .ascii "Unesite string:\0"
unos:            .fill N,1,0
krajnja_poruka:  .ascii "Rezultat je:\0"
rezultat:    .fill N,1,0
greska_a:        .ascii "Pogresan prvi operand!\0"
greska_b:        .ascii "Pogresan drugi operand!\0"
greska_op:       .ascii "Operacija pogresna!\0"
greska_string:   .ascii "Prazan string!\0"

.section .text
.globl main
main:
    movl $4, %eax
    movl $1, %ebx
    leal pocetna_poruka, %ecx
    movl $15, %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 to_int
    cmpl $555, %eax
    je prazan_string
    cmpl $71, %eax
    je pogresan_a
    cmpl $71, %ecx
    je pogresna_op
    cmpl $71, %edx
    je pogresan_b
    addl $4, %esp

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

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

    movl $4, %eax
    movl $1, %ebx
    leal krajnja_poruka, %ecx
    movl $13, %edx
    int $0x80

    movl $4, %eax
    movl $1, %ebx
    leal rezultat, %ecx
    movl $8, %edx
    int $0x80
kraj:
    movl $1, %eax
    int $0x80

pogresan_a:
    movl $4, %eax
    movl $1, %ebx
    leal greska_a, %ecx
    movl $23, %edx
    int $0x80
    jmp kraj

pogresan_b:
    movl $4, %eax
    movl $1, %ebx
    leal greska_b, %ecx
    movl $23, %edx
    int $0x80
    jmp kraj
pogresna_op:
    movl $4, %eax
    movl $1, %ebx
    leal greska_op, %ecx
    movl $19, %edx
    int $0x80
    jmp kraj
prazan_string:
    movl $4, %eax
    movl $1, %ebx
    leal greska_string, %ecx
    movl $15, %edx
    int $0x80
    jmp kraj
#======================================================
#program koji konvertuje dati string u interni oblik, izdvaja operande i operaciju, ili samo operande

.section .text
.globl to_int
to_int:
    pushl %ebp
    movl %esp, %ebp
    subl $12, %esp  #-4(a), -8(op), -12(b)
    pushl %esi
    pushl %edi
    pushl %ebx
    movl 8(%ebp), %esi #pokazivac na string
    movl %esi, %edi    #radi poredjenja adresa
    xorl %eax, %eax    #rezultat pri konverziji
    xorl %edx, %edx    #indikator da je prvi operand upisan
    xorl %ebx, %ebx
konvert:
    movb (%esi), %bl
    cmpb $' ', %bl
    je upis_a
    cmpb $10, %bl
    je upis_b
provera:
    cmpl $0, %edx
    je dalje_oktalni
    cmpl $1, %edx
    je dalje_operacija
    cmpl $2, %edx
    je dalje_heksa
dalje_operacija:
    cmpb $'^', %bl
    je upis_op
    cmpb $'&', %bl
    je upis_op
    cmpb $'|', %bl
    je upis_op
    jmp upis_sab
dalje_oktalni:
    cmpb $'0', %bl
    jl set_a
    cmpb $'7', %bl
    jle broj_okt
    jmp set_a

dalje_heksa:
    cmpb $'0', %bl
    jl set_b
    cmpb $'9', %bl
    jle broj_heksa
    cmpb $'A', %bl
    jl set_b
    cmpb $'F', %bl
    jle veliko_slovo
    cmpb $'a', %bl
    jl set_b
    cmpb $'f', %bl
    jle malo_slovo
    jmp set_b
vrti:
    incl %esi
    movb (%esi), %bl
    cmpb $' ', %bl
    jne konvert
    jmp vrti
broj_heksa:
    movl $16, %ecx
    subb $'0', %bl
    mull %ecx
    andl %edx, %edx
    jnz set_b
    addl %ebx, %eax
    jmp vrti

broj_okt:
    movl $8, %ecx
    subb $'0', %bl
    mull %ecx
    andl %edx, %edx
    jnz set_a
    addl %ebx, %eax
    incl %esi
    jmp konvert
malo_slovo:
    movl $16, %ecx
    subb $87, %bl
    mull %ecx
    andl %edx, %edx
    jnz set_b
    addl %ebx, %eax
    jmp vrti
veliko_slovo:
    movl $16, %ecx
    subb $55, %bl
    mull %ecx
    andl %edx, %edx
    jnz set_b
    addl %ebx, %eax
    jmp vrti

upis_a:
    movl $1, %edx
    movl %eax, -4(%ebp)
    xorl %eax, %eax
    jmp vrti
upis_b:
    cmpl %esi, %edi
    je set
    movl %eax, -12(%ebp)
    jmp kraj_pp
upis_op:
    movl $2, %edx
    movb %bl, -8(%ebp)
    xorl %eax, %eax
    jmp vrti
upis_sab:
    movl $2, %edx
    movb $'+', -8(%ebp)
    xorl %eax, %eax
    jmp vrti
kraj_pp:
    movl -4(%ebp), %eax
    movl -8(%ebp), %ecx
    movl -12(%ebp), %edx
    popl %ebx
    popl %edi
    popl %esi
    leave
    ret

set:
    movl $555, -4(%ebp)  #ako provera u main-u bude ova vrednost, ispis greske o praznom stringu
    jmp kraj_pp

set_b:
    movl $71, -12(%ebp)
    jmp kraj_pp
set_a:
    movl $71, -4(%ebp)
    jmp kraj_pp
set_op:
    movl $71, -8(%ebp)
    jmp kraj_pp
#==========================================

#potprogram koji izvrsava odgovarajucu operaciju, vraca rezultat u eax

.section .text
.globl exe
exe:
    pushl %ebp
    movl %esp, %ebp
    pushl %esi
    pushl %edi
    pushl %ebx
    movl 8(%ebp), %eax #drugi
    movl 12(%ebp), %ecx #operacija
    movl 16(%ebp), %edx #prvi

provera:
    cmpb $'&', %cl
    je do_and
    cmpb $'^', %cl
    je do_xor
    cmpb $'|', %cl
    je do_or
    cmpb $'+', %cl
    je do_add
do_and:
    andl %edx, %eax
    jmp kraj_pp
do_xor:
    xorl %edx, %eax
    jmp kraj_pp
do_or:
    orl %edx, %eax
    jmp kraj_pp
do_add:
    addl %edx, %eax
    notl %eax
    jmp kraj_pp

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

#================================================
#potprogram koji vraca %eax u heksadecimalni string

.section .text
.globl to_hex
to_hex:
    pushl %ebp
    movl %esp, %ebp
    pushl %esi
    pushl %edi
    pushl %ebx
    movl 8(%ebp), %eax #vrednost
    movl 12(%ebp), %esi #pokazivac na string rezultat
    movl %esi, %edi
    movl $16, %ecx
    xorl %ebx, %ebx  #rezultat
konvert:
    xorl %edx, %edx
    divl %ecx # eax= ceo, edx = ostatak
    addb $55, %dl
    movb %dl, (%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