[Arithmétique] - [Affichage] - [Addition] - [Soustraction] - [Multiplication] - [Division]

.:: Rubrique Arithmétique >> Soustraction ::.

Are you reeaady !!!
Bon la soustraction est quasiement pareille que l'addition donc je vais aller très vite.
En gros au lieu d'additionner 2 nombres 2 à 2 comme dans l'algorithme de l'addition, on les soustrait.

Instructions x86 | X

    	_SOUSTRACTION:
    		mov di, _NOMBRE2 	;on pointe avec di sur l'offset de _NOMBRE2
    		mov cl, [ds:di] 	;on récupère la longueur du nombre le plus long qui va nous servir de compteur
    		mov si, _NOMBRE1 	;on pointe avec si sur l'offset de _NOMBRE1
    		mov ch, [ds:si] 	;on récupère la longueur du nombre le plus court qui va nous servir de compteur
    		xor dx, dx 		;registre qui nous servira pour stocker la retenue.
    	_BOUCLE_SUB:
    		inc di
    		inc si
    		xor ax, ax
    		mov al, [ds:di] 	;nombre le plus long
    		xor bx, bx
    		test ch, ch
    		je _SUITE_SUB
    		mov bl, [ds:si] 	;nombre le plus court
    		dec ch
    	_SUITE_SUB:
    		add bx, dx
    		sub ax, bx		;c'est ici qu'on soustrait les 2 nombres
    		mov [ds:di], al
    		shr ax, 8
    		xor bx, bx
    		sub bx, ax
    		mov dl, bl		;retenue
    		dec cl
    		test cl, cl
    		jne _BOUCLE_SUB

    		mov di, _NOMBRE2
    		mov cl, [ds:di]
    		add di, cx
    	_SIZE_SUB:
    		mov al, [ds:di]
    		test al, al
    		jne _FIN_SUB
    		dec di
    		dec cl
    		test cl, cl
    		jne _SIZE_SUB
    		inc cl
    	_FIN_SUB:
    		mov di, _NOMBRE2
    		mov [ds:di], cl

    		ret 			;si non on retourne au programme principal

Si on a compris l'addition, on comprend la sosutraction, sinon... heu... je sais pas. Bon bref, changeons de sujet, je vais en profiter pour vous apprendre à manipuler les variables, je vais vous montrer comment on passe des arguments vers une fonction (exactement comme en c) parceque pour l'instant on ne peut que additionner (ou soustraire) _NOMBRE1 avec _NOMBRE2.
En c on appelle une fonction comme ça:

    	ma_fonction(arg1, arg2, arg3);

En fait quand le compilateur c compile un appel de fonction, il met en premier les arguments sur la pile, il appelle la fonction via l'instruction call et enfin "supprime" les éléments sur la pile:

    	push arg3
    	push arg2
    	push arg1
    	call ma_fonction
    	add sp, 6		;6 car on a empilé 3 éléments de 2 octets chacun => 3*2

Et au moment où l'on rentre dans la fonction, la pile est comme ça:

    		 ------------------------
    	sp	-|	adresse		|
    		 |	de retour	|
    		 |	pour 'ret'	|
    		 ------------------------
    	sp+2	-|	argument1	|
    		 |	|_arg1		|
    		 |			|
    		 ------------------------
    	sp+4	-|	argument2	|
    		 |	|_arg2		|
    		 |			|
    		 ------------------------
    	sp+6	-|	argument3	|
    		 |	|_arg3		|
    		 |			|
    		 ------------------------
    		 	||	||
    		 	\/	\/
    		     Suite de la pile

donc pour atteindre l'argument 2 par exemple il suffit de faire ça:

    	mov	si,	sp			;on pointe sur le haut de la pile
    	add	si,	4			;fait sp<-sp+4 (cf le graph précédent)
    	mov	si,	[ss:si]			;maintenant 'si' pointe sur arg2

ensuite lorsqu'on sort de la fonction on restore sp pour qu'il ait la même valeur qu'avant l'appel de la fonction, donc comme le 'ret' s'est déjà chargé d'enlever l'adresse de retour qui se trouvait sur la pile, il suffit d'ajouter 6 à la pile pour pointer sur le haut de l'ancienne pile. d'où le:

    	add sp, 6

Et voilà vous pouver faire une soustraction maintenant.

On teste:

Et voilà !! motivé pour la suite?

Voici les différentes rubriques:

- Instructions des x86.

- Arithmétique.
  - Affichage.
  - Addition.
  - Soustraction.
  - Multiplication.
  - Division.

Daemonium Albus,
blaizard@caramail.com