[ESAME] togli_pari - simulazione (modificata) 05/12/2017

.586
.model flat
.code

; int togli_pari(unsigned char * src, int lunghezza);
; 1) (Esame superato 0 punti) La funzione deve sostituire in src gli elementi pari ovvero quando src[i] è
; pari. La sostituzione deve essere fatta SOLO SE gli elementi che precedono e seguono l’i-esimo elemento
; sono pari ovvero:
; src[i-1] pari AND src[i+1] pari
; La sostituzione deve essere fatta facendo la media degli elementi che precedono e seguono l’i-esimo
; elemento e ottenendo il numero pari corrispondente:
; src[i]= (src[i-1]+src[i+1])/2 se la media è pari
; oppure
; src[i]= (src[i-1]+src[i+1])/2 +1 se la media è pari
; Il vettore src è pre allocato nel main ed è di lunghezza “lunghezza” e MAI vuoto. Inoltre il primo e l’ultimo
; elemento in questo caso NON sono mai pari.
; La funzione ritorna 0.
; ad. Esempio:
; #include <stdio.h>
;
; int togli_pari(unsigned char*, int);
;
; int main()
; {
;   unsigned char src[6] = { 3, 0, 1, 6, 5, 3 };
;   int ret = togli_pari(src, 6);
; }
; In dst ci saranno {2,4,4,4,6,8} return 0
; 2) (Esame superato 1 punto) se in src i numeri sono tutti dispari NON modificarlo e Ritornare -2
; 3) (Esame superato 2 punti) se in src i numeri sono tutti pari NON modificarlo e Ritornare -1
; 4) (Esame superato 3 punti) se il numero di elementi modificati è PARI e diverso da 0. Il valore di ritorno
; della funzione è il numero di elementi di src modificati.

_togli_pari proc
    push ebp
    mov ebp, esp

    mov ecx, 0
    push ecx

    push ebx
    push esi
    push edi

    mov eax, dword ptr[ebp + 8] ;vettore src
    mov ecx, dword ptr[ebp +12] ;lunghezza vettore

    mov esi, 0
    mov edi, 0      ;numero di numeri dispari
    mov edx, 0      ;numero di numeri pari
    iniziociclop1:
    cmp esi, ecx
    je fineciclop1
        mov bl, byte ptr[eax + esi]
        call ispari
        cmp ebx, 0
        je okpari
            inc edx     ;pari
            jmp goon
        okpari:
            inc edi     ;dispari
        goon:
        inc esi
        jmp iniziociclop1
    fineciclop1:

    cmp edx, ecx
    jne chissenefrega1
    mov eax, -1
    jmp fineciclospeciale
    chissenefrega1:
    cmp edi, ecx
    jne chissenefrega
    mov eax, -2
    jmp fineciclospeciale


    chissenefrega:

    dec ecx                     ;lunghezza vettore - 1
    mov esi, 1
    iniziociclo:
    cmp esi, ecx
    jge fineciclonormale
        mov edx, 0 ; somma

        mov ebx, esi
        push ebx                            ;controllo elemento pari, se non è pari continuo
            mov bl, byte ptr[eax + ebx]
            call ispari
            cmp ebx, 1
            jne continua
        pop ebx

        dec ebx
        push ebx
            mov bl, byte ptr[eax + ebx]
            call ispari
            cmp ebx, 0
            jne continua
        pop ebx
        mov bl, byte ptr[eax + ebx]
        mov dl, bl              ;dl = bl

        mov ebx, esi
        inc ebx
        push ebx
            mov bl, byte ptr[eax + ebx]
            call ispari
            cmp ebx, 0
            jne continua
        pop ebx
        mov bl, byte ptr[eax + ebx]
        add dl, bl              ;dl = bl1 + bl2

        push eax
            mov eax, 0
            mov al, dl
            push edx
                push ecx
                    mov cl, 2
                    div cl
                pop ecx
                mov bl, al
                call ispari
                cmp ebx, 0
                jne sommaancheuno
                    mov edx, dword ptr[ebp + 8] ;vettore src
                    mov byte ptr[edx + esi], al
                    inc dword ptr[ebp - 4]
                    jmp finedellop
                sommaancheuno:
                    mov edx, dword ptr[ebp + 8] ;vettore src
                    mov byte ptr[edx + esi], al
                    add byte ptr[edx + esi], 1
                    inc dword ptr[ebp - 4]
                finedellop:
            pop edx
        pop eax

        continua:
        inc esi
        jmp iniziociclo
    fineciclonormale:
    mov eax, 0
    fineciclospeciale:

    cmp dword ptr[ebp - 4], 0
    je avanti
    mov ebx, dword ptr[ebp - 4]
    call ispari
    cmp ebx, 1
    jne avanti
    mov eax, dword ptr[ebp - 4]
    avanti:


    pop edi
    pop esi
    pop ebx

    mov esp, ebp
    pop ebp

    ret
_togli_pari endp

;============ ISPARI ================
; ebx numero da verificare
; ebx ritorna 0 se dispari 1 se pari
;====================================
ispari proc
    push ebp
    mov ebp, esp

    push esi
    push eax
    push ecx
    push edx

    mov ax, 0
    mov al, bl
    mov cl, 2
    div cl
    mov ebx, 0
    cmp ah, 0
    jne notispari
    mov ebx, 1
    notispari:

    pop edx
    pop ecx
    pop eax
    pop esi

    mov esp, ebp
    pop ebp

    ret
ispari endp
end