TITLE pattern.asm: riconoscimento di pattern binari

COMMENT *

Programma che rileva l'occorrenza di un pattern binario
di Npattern(<=8) bit in un buffer di memoria. 
Cfr. compito 13/9/2006 (dove si chiedeva di lavorare con Npattern=5).

L'algoritmo, dopo aver preparato il pattern da confrontare in modo
che occupi gli Npattern bit più significativi della cella di memoria
"pattern" (allocata come byte), fa scorrere progressivamente, bit a bit, 
il buffer da analizzare, selezionando di volta in volta con una maschera 
un gruppo di Npattern bit, che viene confrontato col pattern. In caso 
di riconoscimento, la posizione del pattern nel buffer viene individuata 
da due interi: la posizione del byte contenente il pattern all'interno 
del buffer, e la posizione del primo bit del pattern all'interno del byte.

*


(...allocazione stack...)

;-----------------------------------------------------------------
;
DATA SEGMENT PUBLIC 'DATA'     ; definizione segmento dati

; qui si hanno le seguenti occorrenze (#byte,#bit): (0,2);(1,0);(1,4);(2,6);(3,2)
 Npattern equ 4       ; non può superare 8! (nel compito era fissata a 5)
 PATTERN DB 00001001B
 BUFFER DB 01100110B,10011001B,01101110B,01100101B 
;
; qui si hanno le seguenti occorrenze (#byte,#bit): (0,1);(1,3);(2,5);(3,1)
; Npattern equ 5       ; non può superare 8!
; PATTERN DB 00011001B
; BUFFER DB 01100110B,10011001B,01101110B,01100101B 
;
; qui si hanno le seguenti occorrenze (#byte,#bit): (2,3);(2,5);(3,4);(6,1)
;Npattern equ 6       ; non può superare 8!
;PATTERN DB 00010101B
;BUFFER DB 10100111B,11010001B,11101010B,10100101B,01101110B,11010100B,00101010B  
Nbytes equ $-BUFFER      ; calcola la lunghezza di BUFFER durante l'assemblaggio

maschera db 11111111B    ; valore di inizializzazione della maschera

max_Npattern equ 8       ; lunghezza massima del pattern 
max_si dw ?


DATA ENDS

;-----------------------------------------------------------------
;
CSEG SEGMENT PUBLIC 'CODE'

MAIN PROC FAR
      ASSUME CS:CSEG,DS:DATA,SS:STACK,ES:NOTHING;


        (...)


        ; preparazione pattern e maschera
        mov dh,pattern
        mov ah,maschera
        mov cx,max_Npattern-Npattern ; = 8-Npattern
maskloop:
        shl dh,1
        shl ah,1                  ; pattern e maschera avranno i (max_Npattern-Npattern) bit meno significativi a 0
        loop maskloop
        mov maschera,ah
        mov pattern,dh

        mov cx,Nbytes
        mov max_si,max_Npattern
        mov bx,0                  ; bx=indirizzo (relativo a BUFFER) del primo byte
        mov ah,buffer[bx]         ; inizializzazione del primo byte della coppia (sempre in ah)

mainloop:
        cmp cx,1                  ; quando cx=1 si lavora solo sull'ultimo byte, e non su una coppia
        jg no_last_byte    
        mov max_si,max_Npattern-Npattern       
no_last_byte:
                                  ; si carica il (nuovo) secondo byte della coppia (sempre in al)
        mov al,buffer[bx+1]       ; N.B. se Nbytes=1 questa non viene eseguita 

        mov si,0                  ; inizializzazione della posizione del bit nel primo byte della coppia
        push ax                   ; si salva ax per riusarlo dopo exitwordloop:
wordloop:
        push ax                   ; si salva ax per riusarlo dentro wordloop (dopo next:)
        and ah,maschera           ; si azzerano i (max_Npattern-Npattern) bit meno significativi di ah
    
        cmp ah,pattern            ; confronto dei quintetti piu' significativi di ah e pattern: 
        je matched                ; N.B. i (max_Npattern-Npattern) bit meno significativi di entrambi sono 0
        jmp next            
matched:   
        (...qui c'e' in bx l'indirizzo (relativo a BUFFER) del byte,
         e in si la posizione del bit nel byte: vanno salvati in memoria,
         mantenendo un opportuno contatore delle occorrenze rilevate...)
next:
        pop ax                    ; va fatto in ogni caso, perche' c'e' stato un push
        inc si  
        cmp si,max_si             ; nel caso dell'ultimo byte, invece di max_Npattern ci vuole (max_Npattern-Npattern)
        je exitwordloop  
        shl ax,1                  ; shift di una posizione per test nuovo quintetto di bit
        jmp wordloop
exitwordloop:
        pop ax                    ; va fatto in ogni caso, perche' c'e' stato un push
        dec cx                    ; equivale a loop mainloop (qui etichetta troppo lontana per usarlo)        
        je exitmainloop
        inc bx            
        mov ah,al                 ; il secondo byte diventa il primo della coppia
        jmp mainloop

exitmainloop:
       
        RET                       ; si restituisce il controllo al DOS

MAIN ENDP


CSEG ENDS

END MAIN                     ; il programma comincia all'indirizzo di MAIN