;Divise un dividende unsigned long par un diviseur unsigned sur 16 bits 
;Fonctions appelables depuis C en near: 
;unsigned int Div(unsigned int * Dividend, 
;int DividendLength, unsigned int Divisor, 
;unsigned int * Quotient); 
;  
; Retourne le reste de la division. 
; 
; Testé avec TASM. 
parms               struc         
                    dw            2         dup   (?) ;BP empilé & adresse
                                                      ;de retour
Dividend            dw            ?         ;pointeur sur la valeur à diviser, 
                                            ;stockée dans l'ordre d'Intel,
                                            ;lsb à l'adresse la plus basse, msb la 
                                            ;plus haute. Doit être composée d'un 
                                            ;nombre entier de mots 
DividendLength      dw            ?         ;nombre d'octets de Dividend. Doit 
                                            ;être un multiple de 2
Divisor             dw            ?         ;valeur pour diviser. Ne doit pas être
                                            ;zéro ou bien une interruption Divide
                                            ;By Zero interrupt se produira 
Quotient            dw            ?         ;pointeur sur le tampon dans lequel 
                                            ;sera stocké le résultat de la,  
                                            ;division dans l'ordre d'Intel. 
                                            ;Le quotient retourné est de même 
                                            ;longueur que le dividende 
parms               ends          
                    .model        small 
                    .code         
                    public        _Div 
_Div                proc          near 
                    push          bp        ;préserve la stack frame de l'appelant
                    mov           bp,sp     ;pointe sur notre stack frame 
                    push          si        ;préserve les variables registre de 
                                            ;l'appelant 
                    push          di 
                    std                     ;nous travaillons de msb à lsb 
                    mov           ax,ds 
                    mov           es,ax     ;pour STOS 
                    mov           cx,[bp+DividendLength] 
                    sub           cx,2 
                    mov           si,[bp+Dividend] 
                    add           si,cx     ;pointe sur le dernier mot du 
                                            ;dividende (le mot de poids fort) 
                    mov           di,[bp+Quotient] 
                    add           di,cx     ;pointe sur le dernier mot du quotient
                                            ;(le mot de poids fort) 
                    mov           bx,[bp+Divisor] 
                    shr           cx,1 
                    inc           cx        ;nombre de mots à traiter 
                    sub           dx,dx     ;convertit le mot diviseur initial 
                                            ;en une valeur sur 32 bits pour DIV
DivLoop:            
                    lodsw                   ;récupère le prochain mot de poids 
                                            ;fort du diviseur 
                    div           bx 
                    stosw                  ;sauve le mot du quotient 
                                           ;DX contient le reste, prêt à
                                           ;l'ajouter au prochain mot du diviseur 
                    loop          DivLoop 
                    mov           ax,dx     ;retourne le reste 
                    cld                     ;restaure le paramètre par défaut du 
                                            ;drapeau Direction  
                    pop           di        ;restaure les variables registre de 
                                            ;l'appelant 
                    pop           si 
                    pop           bp        ;restaure la stack frame de l'appelant
                    ret           
_Div                endp          
                    end