; Routine Assembleur pour le Listing 16.2. Parcourt un tampon, de
; longueur BufferLength, en comptant les mots et en mettant à jour WordCount 
; , en utilisant une table pré-calculée. BufferLength
; doit être > 0. *CharFlag et *WordCount doivent être = 0 au premier
; appel. Testé avec TASM.
; Appelable en C near comme suit:
;       void ScanBuffer(char *Buffer, unsigned int BufferLength,
;               char *CharFlag, unsigned long *WordCount);

parms   struc
        dw      2 dup(?)        ;adresse de retour & BP empilés
Buffer  dw      ?               ;tampon à analyser
BufferLength dw ?               ;longueur du tampon à analyser
CharFlag dw     ?               ;pointeur sur le drapeau du dernier
                                ;caractère traité en entrée (0 à l'appel
                                ;initial). Mis à jour en sortie 
WordCount dw    ?               ;pointeur sur le compteur de mots sur 32 bits
                                ;trouvé (0 à l'appel initial)
parms   ends

        .model  small
        .data
; Table des statuts caractères/non caractères des octets valant entre 0-255 
;(128-255 sont des doublons de 0-127 pour masquer le bit 7, que certains 
; traitement de texte utilise comme drapeau interne).

CharStatusTable label   byte
        REPT    2
        db      39 dup(0)
        db      1               ;apostrophe
        db      8 dup(0)
        db      10 dup(1)       ;0-9
        db      7 dup(0)
        db      26 dup(1)       ;A-Z
        db      6 dup(0)
        db      26 dup(1)       ;a-z
        db      5 dup(0)
        ENDM

        .code
        public  _ScanBuffer
_ScanBuffer     proc    near
        push    bp              ;préserve la stack frame de l'appelant
        mov     bp,sp           ;configure la stack frame localement
        push    si              ;préserve les variables registre de l'appelant
        push    di

        mov     si,[bp+Buffer]  ;pointe sur le tampon à analyser
        mov     bx,[bp+WordCount]
        mov     di,[bx]         ;récupère le compteur de mots sur 32 bits courant
        mov     dx,[bx+2]
        mov     bx,[bp+CharFlag]
        mov     al,[bx]         ;récupère CharFlag courant
        mov     cx,[bp+BufferLength] ;récupère le nombre d'octets à analyser
        mov     bx,offset CharStatusTable
ScanLoop:
        and     al,al           ;ZF=0, si le dernier octet est un caractère
                                ;ZF=1 si ce n'est pas le cas
        lodsb                   ;récupère le prochain octet
                                ;***n'altère pas les drapeaux***
        xlat                    ;pré-calcule son statut caractère/non caractère
                                ;***n'altère pas les drapeaux***
        jz      ScanLoopBottom  ;ne compte pas un mot si le dernier octet
                                ;n'était pas un caractère
        and     al,al           ;dernier octet était un caractère; est-ce
                                ;que l'octet courant est un caractère ?
        jz      CountWord       ;non, donc comptons un mot
ScanLoopBottom:
        dec     cx              ;décompte la longueur du tampon
        jnz     ScanLoop
Done:
        mov     si,[bp+CharFlag]
        mov     [si],al         ;paramètre un nouveau CharFlag
        mov     bx,[bp+WordCount]
        mov     [bx],di         ;paramètre un nouveau compteur de mots
        mov     [bx+2],dx

        pop     di              ;restaure les variables registre de l'appelant
        pop     si
        pop     bp              ;restaure la stack frame de l'appelant
        ret

        align   2
CountWord:
        add     di,1            ;incrémente le compteur de mots
        adc     dx,0
        dec     cx              ;décompte la longueur du tampon
        jnz     ScanLoop
        jmp     Done
_ScanBuffer     endp
        end