Dépassement de division

**Spacy_green** · 25/02/2006, 13h12

Bonjour à tous!

J'ai fait une procédure qui calcule la somme de N nombres entiers, ou N est un nombre défini sur un octet que l'utilisateur saisit.
Quand j'implémente la procédure dans le programme principal, on m'affiche le message "dépassement de division", c'est dû à quoi s'il vous plait ?

Voici le code de la procédure :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
SN1 proc near
;c'est une procédure qui calcule la somme des N premiers nombre grace à la formule s=N*(N+1)/2
 
 
 
MOV AL,N
ADD AL,1	;N<-N+1
MOV BL,N	;on va multiplier par N
MUL BL		;on a effectué la multiplication N*(N+1),
XOR BX,BX       ; le résultat est placé dans AX
MOV Bx,2        ;on va diviser par 2
DIV Bx          ;cette instruction divise dx:AX par 2,
                ; place le quotient dans Ax et le reste dans dx
 
 
 
		mov	dx, '$'				;empiler le caractère '$'
		push	dx					; (comme repère)
		mov	bx, 10				;on va diviser par 10
 
boucle1:							;pour trouver les chiffres
		xor	dx, dx				;mettre DX à 0 pour la division
		div	bx					;diviser !
		push	dx					;empiler un chiffre
		or	ax, ax				;a-t-on fini ?
		jnz	boucle1				;boucler sinon !
 
boucle2:							;boucle pour l'affichage
		pop	ax					;obtenir un chiffre
		cmp	ax, '$'				;est-ce la fin ?
		je	termine				;oui ? alors quitter !
		add	al, '0'				;ajouter le code ASCII '0'
		xchg	al, dl				;mettre dans DL
		mov	ah, 02h				;écrire un caractère
		int	21h					; à l'écran !
		xchg	dl, al				;restaurer DL
		jmp	boucle2				;prochain chiffre
termine:
 
 
ret
SN1 endp

**Alcatîz** · 25/02/2006, 13h48

Bonjour !

Le dividende se trouve bien dans DX:AX mais la valeur de DX est indéfinie avant ta division, d'où peut-être l'erreur. Il faudrait donc mettre DX à 0.

Une petite remarque en passant : pour une division par 2, un décalage de 1 bit vers la droite est beaucoup plus performant que l'instruction div.

**Spacy_green** · 25/02/2006, 13h58

Merci beaucoup, j'ai initialisé DX à 0 et ça a marché

Pourrais tu me dire quelle instruction décale d'un bit vers la droite stp?

**Juju_41** · 25/02/2006, 14h14

Bonjour

L'instruction suivante permet de décaler vers la droite le registre reg de n bits :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

SHR reg,n

**Alcatîz** · 25/02/2006, 14h19

Instructions de décalage :

SHR permet de diviser par 2 de l'entier non signé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
              0 1 1 0 1 0 1 1
0 injecté --> 0 0 1 1 0 1 0 1 --> 1 dans le flag carry

SAR permet de diviser par 2 de l'entier signé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
                        1 1 0 1 0 1 1 0
bit signe réinjecté --> 1 1 1 0 1 0 1 1 --> 0 dans le flag carry

Avec SAR, il faut faire attention : si le flag carry vaut 1, il faut soustraire 1 du quotient.

[edit]
Désolé Juju, posté en même temps que toi
[/edit]

**Spacy_green** · 27/02/2006, 11h20

merci beaucoup pour les réponses, mais mon programme en entier ne marche tjs pas

Je l'ai fait et refait plusieurs fois mais en vain, je ne sais pas ou est l'erreur

Pourriez vous m'aider s'il vous plait?? (c'est un programme qui calcule la somme des N premiers entiers grace à la formule N*(N+1)/2 et la convertit dans une base B choisie par l'utilisateur ensuite l'affiche à l'écran (enfin c'est ce qu'il est sensé faire mais bon..

)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
donnees segment
 
        B dw ?
        N db ?
	S dw ?
	msg1 db "entrer le nombre à sommer",10,13,'$'
	msg2 db "entrer la base",10,13,'$'
	msg3 db "la somme calculée dans la base est:",10,13,'$'
donnees ends
 
pile segment stack
	dw 100 dup(?)
pile ends
 
code segment
	assume cs:code
        assume ds:donnees
	assume ss:pile
 
debut:
	mov ax,donnees
	mov ds,ax
	jmp main
 
;*****************************************************************************************************************
GetNumber proc near		;c'est une procédure qui lit un nombre tappé au clavier et qui stocke le résultat dans une variable N
 
xor cx,cx 
lecture:
 
MOV AH,1  			;fonction lecture d'un caractère avec écho
int 21H				;résultat dans AL
 
CMP AL,"0"	;on compare AL et le code ASCII de 0
JB fin          ;saut vers fin si le premier opérande est inférieur au deuxième
CMP AL,"9"	;on compare AL et le code ASCII de 9
JA fin		;on saute vers fin si le premier opérande est superieur au deuxieme
sub AL,'0'	;sinon on va faire une soustraction pour obtenir le chiffre correspondant au code ascii saisi
add al,cl
 
SHL al,1         
 
MOV DL,al
 
 
 
 
SHL al,1
SHL al,1
add al,dl
mov cl,al
 
jmp lecture
 
 
fin:
mov al,cl
mov  N,al
ret
GetNumber endp
 
;***************************************************************************************************************
 
SN1 proc near
;c'est une procédure qui calcule la somme des N premiers nombre grace à la formule s=N*(N+1)/2
 
ADD AL,1	;N<-N+1
MOV BL,al	;on va multiplier par N
MUL BL		;on a effectué la multiplication N*(N+1),
                ; le résultat est placé dans AX
XOR DX,DX
MOV BX,2        ;on va diviser par 2
DIV BX          ;cette instruction divise AX par 2,
                ; place le quotient dans AX et le reste dans DX (=0)
mov S,ax
ret
SN1 endp
 
;***************************************************************************************************************
conversionB proc near
 
mov bp,sp
push bp
 
mov bx,[bp+4]
mov ax,[bp+6]
 
boucle1:
	xor dx,dx
	div bx
	push dx
	or ax,ax
jnz boucle1
 
affichage:
 
pop dx
cmp dx,bp
je termine
 
add dl,"0"
mov ah,2
int 21h
 
jmp affichage
 
termine:
 
pop bp
ret 
 
ConversionB endp
;********************************************************************************************************************
GetBase proc near
 
;c'est une procédure qui lit un nombre tappé au clavier et qui stocke le résultat dans une variable B
lecture2:
MOV AH,1                  ;fonction lecture d'un caractère avec écho
int 21H	                ;résultat dans AL
xor cx,cx
CMP AL,"0"	;on compare AL et le code ASCII de 0
JB fin3                        ;saut vers fin si le premier opérande est inférieur au deuxième
CMP AL,"9"	;on compare AL et le code ASCII de 9
JA fin3                       ;on saute vers fin si le premier opérande est superieur au deuxieme
 
Sub AL,"0"                 ; sinon le chiffre= code ASCII-ASCII(0) 
add al,cl
 
 
   SHL AL,1                    ; et al <- 10*al + AL 
   Mov BL,al
   SHL al,1 
   SHL al,1 
   Add al,BL
   mov cl,al 
 
   jmp lecture2
 
fin3:
 
mov bx,cx
mov B,bx
ret
GetBase endp
 
 
;*******************************************************************************************************************
 
main:
 
LEA DX,msg1
MOV AH,9
INT 21H
 
 
CALL GetNumber
 
 
mov al,N
CALL SN1
;XOR BX,BX
 
 
 
LEA DX,msg2
MOV AH,9
INT 21H
 
 
CALL GetBase
 
 
 LEA DX,msg3
MOV AH,9
INT 21H
 
 
push S
push B
CALL conversionB
 
 
 
 
MOV AX,4C00H
INT 21H
 
code ends
end  debut

**Forthman** · 27/02/2006, 13h32

Envoyé par Spacy_green

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
MOV AL,N
ADD AL,1	;N<-N+1
MOV BL,N	;on va multiplier par N
MUL BL		;on a effectué la multiplication N*(N+1),
XOR BX,BX       ; le résultat est placé dans AX
MOV Bx,2        ;on va diviser par 2
DIV Bx          ;cette instruction divise dx:AX par 2,
                ; place le quotient dans Ax et le reste dans dx

Hello,

Que vaut DX ?
Une division par un registre 16 bits (ici BX) oblige une valeur
contenue dans DX:AX
si DX <> 0 alors il se peut que le resultat ne tienne pas dans AX
tu devrais mettre un CWD avant de faire le DIV

a+ Francois (pour le reste j'ai pas regarde)

**Forthman** · 27/02/2006, 22h26

desole d'avoir repondu la meme chose que Alcatiz, avec 2 jours de retard,
j'ai fait defile l'ecran trops vite

a+ Francois

**Spacy_green** · 01/03/2006, 16h04

Salut à tous, merci beaucoup pour votre aide, j'ai énormément appris

J'ai pu finalement aboutir à une version finale du programme qui marche, que je vais mettre à la disposition d'autres débutants en assembleur (peut etre ça servirait à qqch

)

P.S: je suis encore débutante donc il se peut que ma version soit la moins bonne mais l'essentiel c'est que ça marche

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
 
donnees segment
 
        B db ?
        N db ?
	S dw ?
	vecteur dw ?
	 chiffre dw ?
	msg1 db 13,"entrer le nombre a sommer",10,13,'$'
	msg2 db  10,13,"entrer la base" ,10,13,'$'
	msg3 db 10,13,"nombre invalide!! ressayez ",10,13 , '$'
	msg4 db 10, 13,"base invalide!! ressayez " ,10,13, '$'
	msg5 db 10,13,"la somme calculee dans la base est:",10,13 , '$'
 
donnees ends
 
pile segment stack
	dw 100 dup(?)
pile ends
 
code segment
	assume cs:code
        assume ds:donnees
	assume ss:pile
 
debut:
	mov ax,donnees
	mov ds,ax
	jmp main
 
;****************************************************************
 
GetNumber  proc near
 
 
xor BX,BX
xor DX,DX
saisie: 
MOV CX,3
boucle:
mov ah,1
int 21h
 
 
 
cmp al,'0'
jb erreur
 
cmp al,'9'
ja erreur
 
sub al,'0'
XOR AH,AH
PUSH AX 
 
 
mov dh,al
 
add dh,dl
mov bl,dh
SHL dh,1
 
mov dl,dh
 
SHL dh,1
 
SHL dh,1
 
add dl,dh
 
 
 mov N,bl
 
LOOP boucle
 
 
 
POP AX
MOV DH,AL
POP AX
MOV BH,AL
POP AX
MOV bl,AL
 
CMP BL,0
JE fin
CMP BL,1
JE fin
CMP BL,2
JE test2
JMP erreur
 
test2:
CMP BH,5
JBE test3
JMP erreur
 
test3:
CMP DH,4
JBE fin
JMP erreur
 
erreur:
lea dx,msg3
mov ah,9
int 21h
jmp saisie
 
 
 
fin:
 
 
ret
GetNumber endp
;******************************************************************
GetBase proc near
 
 
 
 
xor bx,bx
saisie1:
mov ah,1
int 21h
 
cmp al,'0'
jb fin3
 
cmp al,'9'
ja fin3
 
cmp al,'1'
jbe secondesaisie
 
sub al,'0'
mov bl,al
JMP fin2
 
 
secondesaisie:
sub al,'0'
mov bl,al
 shl bl,1
 mov bh,bl
 shl bl,1
 shl bl,1
 add bh,bl
mov ah,1
int 21h
cmp al,'0'
jb fin3
cmp al, '6'
ja fin3
sub al,'0'
mov bl,al
add bl,bh
jmp fin2
 
fin3:
lea dx,msg4
mov ah,9
int 21h
jmp saisie1 
 
 
 
 
 
 
 
fin2:
 
ret  
 
GetBase endp
 
 
 
 
 
;*********************************************************************
SN1 proc near
;c'est une procédure qui calcule la somme des N premiers nombre grace à la formule s=N*(N+1)/2
MOV AL,N
MOV BL,al
ADD AL,1	 
 
MUL BL		 
XOR DX,DX
MOV BX,2        
DIV BX           
 
RET         
SN1 endp
 
;*********************************************************************
 
 
        conversionB PROC NEAR 
 
 
 
 
 
 xor dx,dx                             
  xor bh,bh                            
 
   divsucc: mov cx,ax                           
    div bx                                 
    mov di,ax ;stock le quotien de la division de ax/bx dans di                                 
     mul bx                                
     sub cx,ax                                
     cmp cl,9
     ja hexa
     add cl,'0'
     jmp stock
     hexa: sub cl,10
      add cl,'A'
      stock: mov[si],cl
      inc si
      mov ax,di ;on remet,dans ax, le quotien contenu dans di
      cmp ax,0
      ja divsucc
      mov al,'$'
      mov [si],al
 
 
 
 
        RET                                
        conversionB endp                        
 
;********************************************************************************
 
        affichage PROC NEAR  
dec si 
aff:
mov al,[si]
xchg [di],al
mov [si],al
dec si
inc di 
cmp si,di
ja aff
 
 
 lea dx,vecteur
 mov ah,9
int 21h
 
        RET                               
        affichage endp                    
;********************************************************
main:
 
 
 LEA DX,msg1
 MOV AH,9
 INT 21H
 
 
 
 
call GetNumber
 
 
 
mov AL,N	
call SN1
mov S,ax
 
 
LEA DX,msg2
MOV AH,9
INT 21H
 
 
call GetBase
 
mov B,bl
 
 
LEA DX,msg5
MOV AH,9
INT 21H
 
 
 
 
mov ax,S
 mov bl,B
 
lea si,vecteur ; met l'addresse  de vecteur dans si
 
 
CALL conversionB
 
 
 
 
 
lea di,vecteur
CALL affichage
 
 
 
 
 
MOV AX,4C00H
INT 21H
 
code ends
end  debut

WO · 01/03/2006, 18h35

Bravo pour ta persévérance

Veille simplement à ne pas changer de casse en plein milieu (ça n'apporte pas forcément en lisibilité)

Une petite remise dans l'ordre serait sympa et permettrait de lire tout ça de manière plus logique (pense aux débutants, justement, ).

Les sauts de lignes pour mieux repérer les labels, c'est souvent important.

attention aussi d'utiliser les tabulations à bon escient... (pour les symétries push/pop par exemple)

En fait, il te reste à présenter ton code de manière logique et claire. Je suis sûr que s'il reste des choses à adapter (!) tu le verras plus directement…

Encore bravo (c'est cool de faire un truc qui, finalement, marche...

)

@+WO

**Spacy_green** · 01/03/2006, 21h07

En fait la mise en forme est la dernière chose à laquelle j'ai pensé

ce qui m'importait c'etait que le programme marche ..

Merci beaucoup pour les remarques, j'en tiendrai compte la prochaine fois

**Forthman** · 01/03/2006, 21h35

Mais il n'est pas trop tard tu sais

Moi aussi, quand je suis lance dans la prog, je ne suis
pas tres attentif a la presentation, mais des que je relis mon code
je range tout ca bien comme il faut (j'ai failli dire "bien propre"

)

Alors tu me reprends ce code, tu le fait tout beau et tu edite ton
premier message

a+ Francois

PS: felicitation, ca fait toujours plaisir de faire un truc qui marche, meme minime