Calcolatori elettronici - #503

DIM EQU 11

.MODEL SMALL
.STACK
.DATA

STRINGA DB "notte rossa"
DIM_AGG DB ?

.CODE
.STARTUP

LEA AX, STRINGA
PUSH AX                         ; Metto nello stack il primo parametro (indirizzo)
MOV AX, DIM
PUSH AX                         ; Metto nello stack il secondo parametro (dimensione)
SUB SP, 2                       ; Faccio spazio per il parametro di ritorno
CALL CONVERTI
POP AX
MOV DIM_AGG, AL
ADD SP, 4                       ; "Riavvolgo" lo stack (4 = 2*n)
                                ; con n = # parametri passati (non di ritorno!)

.EXIT

CONVERTI PROC
    MOV BP, SP                  ; PRIMA istruzione di qualunque procedura che usa lo stack!

    PUSH SI                     ; Prima anche delle PUSH :)
    PUSH CX
    PUSH AX
    PUSH DX


    MOV SI, [BP+6]              ; In SI ho l'indirizzo di partenza della stringa
    MOV CX, [BP+4]              ; In CX ho la lunghezza originale della stringa
    DEC CX                      ; ... l'ultimo carattere però non lo devo confrontare con il successivo :)
    MOV AX, 0                   ; Tengo un registro per contare quante cancellazioni ho fatto

    CICLO: MOV DL, [SI]         ; Prendo il carattere in posizione i
           CMP DL, [SI+1]       ; Confronto con quello in posizione i+1
           JNE NEXT             ; Sono uguali?

    INC AX                      ; Sono uguali. Devo effettuare uno shift: incremento il contatore

    MOV [BP-2], SI              ; Salvo i registri SI/CX (potevo farlo con la POP, è giusto per esercizio)
    MOV [BP-4], CX
    SHF: MOV DL, [SI+1]         ; Shifto tutti i caratteri da quello di partenza al finale
         MOV [SI], DL           ; (faccio CX passi!)
         INC SI
         LOOP SHF
    MOV CX, [BP-4]              ; Ripristino il corretto valore dei registri
    MOV SI, [BP-2]
    LOOP CICLO                  ; Nascosto in questa istruzione c'è il fatto che ho decrementato
                                ; la stringa di 1 carattere (il puntatore SI NON si sposta!)

NEXT: INC SI                    ; Non sono uguali: passo al successivo carattere
      LOOP CICLO                ; e diminuisco il numero di passi (ma non la lunghezza!)

      MOV CX, [BP+4]            ; Riprendo la lunghezza originale della stringa
      SUB CX, AX                ; Sottraggo il numero di shift che ho fatto = nuova lunghezza
      MOV [BP+2], CX            ; Salvo il ritorno nello stack

    POP DX                      ; Ripristino tutti i registri coinvolti
    POP AX
    POP CX
    POP SI

    RET
CONVERTI ENDP

END