[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. 

	_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:

Daemonium Albus,
blaizard@caramail.com