konvert(ceo_razlomljen)

#program koji konvertuje razlomljeni decimalni iz znakovnog u interni i u zavisnosti od karaktera izvrsava odgovarajucu operaciju nad celim, odnosno razlomljenim delom broja.(unos je jedan string npr, 123.456 razmak operacija) Dozvoljene operacije  ^(xorl), &(and). Ako karakter odgovara ovim operacijama primeni ih na celom delu, ako ne odgovara, primeni ~(not) na razlomljenom delu. Rezultat vrati u binarni oblik, takodje ispisi poruke ukoliko dodje do pogresnog unosa.
#autor: Branislav Nikolić

.section .data
N = 50
pocetna:  .ascii "Unesi string:\0"
unos:     .fill N,1,0
rezultat: .fill N,1,0
greska_a: .ascii "Pogresan operand a.\0"
greska_b: .ascii "Pogresan operand b.\0"
krajnja:  .ascii "Rezultat je:\0"
pogresan_unos: .ascii "Pogresan unos!\0"
.section .text
.globl main
main:
    movl $4, %eax
    movl $1, %ebx
    leal pocetna, %ecx
    movl $13, %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 greska_unos
    cmpl $71, %eax
    je greska_operand_a
    cmpl $71, %edx
    je greska_operand_b
    addl $4, %esp

    pushl %eax #celi
    pushl %ecx #razl
    pushl %edx #op
    call exe
    addl $12, %esp

    xorl %ebx, %ebx
    leal rezultat, %ebx
    pushl %ecx
    pushl %ebx
    call to_char
    addl $8, %esp

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

greska_operand_a:
    movl $4, %eax
    movl $1, %ebx
    leal greska_a, %ecx
    movl $19, %edx
    int $0x80
    jmp kraj
greska_operand_b:
    movl $4, %eax
    movl $1, %ebx
    leal greska_b, %ecx
    movl $19, %edx
    int $0x80
    jmp kraj
greska_unos:
    movl $4, %eax
    movl $1, %ebx
    leal pogresan_unos, %ecx
    movl $14, %edx
    int $0x80
    jmp kraj

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




#potprogram koji konvertuje decimalni razlomljeni string i pamti operaciju, celi deo u eax, razlomljeni u ecx, operacija u edx

.section .text
.globl to_int
to_int:
    pushl %ebp
    movl %esp, %ebp
    pushl %esi
    pushl %edi
    pushl %ebx
    movl 8(%ebp), %esi #pokazivac na string unos
    movl %esi, %edi    #kod poredjenja adresa za prazan string
    movl $10, %ecx  #baza
    xorl %ebx, %ebx #karakter
    xorl %edx, %edx #indikator upisa
    xorl %eax, %eax #rezultat
konvert_pocetak:
    movb (%esi), %bl
    cmpb $' ', %bl
    je set_unos
    cmpb $10, %bl
    je set_unos

    cmpl $0, %edx
    je konvert_nastavi
    cmpl $1, %edx
    je konvert_razlomi

provera_operacije:
    cmpb $'^', %bl
    je upisi_op
    cmpb $'&', %bl
    je upisi_op
    jmp upisi_op_not

konvert_nastavi:
    cmpb $'.', %bl
    je upisi_a
    cmpb $'0', %bl
    jl set_a
    cmpb $'9', %bl
    jle broj
    jmp set_a
broj:
    subb $'0', %bl
    mull %ecx
    andl %edx, %edx
    jnz set_a
    addl %ebx, %eax
    jc set_a
    incl %esi
    jmp konvert_pocetak
upisi_a:
    movl %eax, -4(%ebp)
    movl $1, %edx
    xorl %eax, %eax
    incl %esi
    jmp konvert_pocetak
upisi_b:
    movl %eax, -8(%ebp)
    movl $2, %edx
    xorl %eax, %eax
do_operacije:
    incl %esi
    movb (%esi), %bl
    cmpb $' ', %bl
    je do_operacije
    jmp konvert_pocetak
upisi_op:
    movb %bl, -12(%ebp)
    xorl %eax, %eax
    incl %esi
    movb (%esi), %bl
    cmpb $10, %bl
    je kraj_pp
    jmp set_op

upisi_op_not:
    movb $'~', -12(%ebp)
    jmp kraj_pp


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

konvert_razlomi:
    movl $10, %ecx
    xorl %edx, %edx #indikator upisa
    xorl %eax, %eax #rezultat

nastavi_razlomi:
    movb (%esi), %bl
    cmpb $10, %bl
    je set_b
    cmpb $' ', %bl
    je upisi_b

    cmpb $'0', %bl
    jl set_b
    cmpb $'9', %bl
    jle broj_b
    jmp set_b
broj_b:
    subb $'0', %bl
    mull %ecx
    andl %edx, %edx
    jnz set_b
    addl %ebx, %eax
    jc set_b
    cmpl $1000000000, %eax
    jae set_b

    incl %esi
    jmp nastavi_razlomi



kraj_pp:
    movl -4(%ebp), %eax #celi deo
    movl -8(%ebp), %ecx #razlomljeni deo
    movl -12(%ebp), %edx #operacija
    popl %ebx
    popl %edi
    popl %esi
    leave
    ret

#=========================================================
#ispitivanje operacije i primena na operandima
.section .text
.globl exe
exe:
    pushl %ebp
    movl %esp, %ebp
    pushl %esi
    pushl %edi
    pushl %ebx
    movl 8(%ebp), %eax #operacija
    movl 12(%ebp),%ebx #razl
    movl 16(%ebp), %ecx #celi

provera_operacije:
    cmpb $'^', %al
    je xor_a
    cmpb $'&', %al
    je and_a
    cmpb $'~', %al
    je not_b
xor_a:
    xorl %ecx, %ecx
    jmp kraj_pp
and_a:
    andl %ecx, %ecx
    jmp kraj_pp
not_b:
    notl %ebx
    movl %ebx, %ecx
    jmp kraj_pp

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

#===================================================
# rezultat ecx vrati u string rezultat u binarnom formatu
.section .text
.globl to_char
to_char:
    pushl %ebp
    movl %esp, %ebp
    pushl %esi
    pushl %edi
    pushl %ebx
    movl 8(%ebp), %esi #pokazivac stringa rezultat
    movl %esi, %edi
    movl 12(%ebp), %eax #vrednost za konverziju

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