Discussion :

[zanzarah84]

Bonjour

J'ai un problème pour écrire un programme : un tableau de 11 valeurs est introduit en mémoire à l’adresse effective TAB1. Chaque valeur est un octet. On veut rechercher parmi les 10 premières valeurs les valeurs multiples de la onzième valeur, les sauvegarder dans une zone d'adresse effective TAB2, puis les trier dans l'ordre décroissant.

La question est de réaliser l’édition, l'assemblage et le débogage, même l'organigramme qui permet de réaliser ce programme.

[Invité]

Je ne connais pas emu386 et je travaille uniquement sous Windows 32 bits en modèle flat avec les assembleurs MASM ou GoAsm. J’ai proposé, dans une autre discussion, quelque chose qui ressemble à ce problème. Il s’agissait de trier 7 valeurs Word non-signées puis de les afficher.
Voici ce que ça donne en affichage :

Pièce jointe 370101

C’est du MASM écrit pour Windows. L'assemblage et l'édition de liens se font respectivement avec ML.exe et Link.exe que tu peux trouver sur le site MASM32.
Le programme commence par un tri sur 7 words non-signés. Il s’agit de la méthode dite de “tri à bulles” (bubble sort) qui a le mérite d’être simple à mettre en œuvre à défaut d’être rapide. Je ne la commente pas tant elle est abondamment décrite sur le Net.
Le programme se termine par une MessageBox dont la chaîne a afficher est préalablement remise en forme.
Un point important de cette remise en forme est un sous-programme qui affiche chaque nombre en ASCII et, surtout, dans le bon ordre des chiffres (process d’aller-retour dans la pile).
Évidemment, c’est avant le tri que tu devras écrire le process capable de déterminer si chacune des 10 valeurs est multiple de la onzième. Je ne t’apprendrai rien en te rappelant que cette caractéristique est déterminée en constatant que le reste de la division de la valeur à traiter par la onzième doit être nulle. Veille surtout à tester le fait que le diviseur n’est pas nul, à défaut de quoi tu t’exposes à une exception si cette condition est vraie.
Si tu traites des octets, tu devras adapter le programme qui suit. Mais, si tu travailles dans un environnement 32 bits, maintiens les pointeurs ESI, EDI et le compteur ECX en 32 bits quoi qu’il arrive sinon tu risques d’avoir des surprise désagréables.

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
;================================================================
;                   TriBulles.asm
;    Programme de démo de Tris de données à bulles
;----------------------------------------------------------------
.386
.model flat,stdcall
option casemap:none
include \masm32\include\windows.inc
include \masm32\include\user32.inc
include \masm32\include\kernel32.inc
includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib
 
.data
MsgBoxCaption	db 'Tri à bulles',0
 
; NB : la liste de valeurs ci-dessous peut être étendue en cas de besoin
DonneesATrier	dw 23
				dw 56
				dw 2
				dw 127
				dw 5
				dw 35
LData			equ ($-DonneesATrier)/2
 
AvantTri		db 'Avant tri :',13,10,0
ApresTri		db  13,10,'Après tri :',13,10,0
 
BufferAscii		db 100 dup(0)
 
.code
Start:
cld
 
; Copie message "Avant tri" dans le buffer
mov esi, offset AvantTri 
mov edi, offset BufferAscii
BcleMsg1:
lodsb
cmp  al,0
je  CopieDataAvant
stosb
jmp  BcleMsg1
 
; Copie des données avant tri dans le buffer
CopieDataAvant:
mov esi,offset DonneesATrier
mov ecx,LData
BcleDataBuffer1:
call ConvertAscii
loop BcleDataBuffer1
 
; Copie message "Après tri" dans le buffer
mov esi, offset ApresTri 
BcleMsg2:
lodsb
cmp  al,0
je  BcleOut
stosb
jmp  BcleMsg2
 
;==== Procédure de tri à bulles =========
BcleOut:
xor ebx,ebx	; bx = 0
mov ecx,LData-1
mov esi, offset DonneesATrier 
 
BcleIn:
lodsw 
cmp ax,[esi]
ja  VBcleIn
xchg ax,[esi]
mov [esi-2],ax
mov ebx,1	; flag signalant qu'une permutation a été faite
VBcleIn:
loop BcleIn
 
cmp ebx,1	; une seule (ou plus) permutation faite
je  BcleOut
 
 
; A ce stade, les données sont censées être triées
; on va maintenant convertir les résultats en ASCII dans BufferAscii; pour les afficher dans une MessageBox
 
mov esi, offset DonneesATrier 
mov ecx,LData
BcleDataBuffer:
call ConvertAscii
loop BcleDataBuffer
xor  eax,eax
stosb				; zéro en fin de message
 
;------------ Boîte de message d'affichage puis sortie -------------
 
invoke MessageBoxA, NULL, addr BufferAscii, addr MsgBoxCaption, MB_OK
invoke ExitProcess, NULL
 
;================================================================================
;        Conversion valeur binaire format Word en chaîne ASCII dans le Buffer
;--------------------------------------------------------------------------------
 
ConvertAscii:
push ebx
push ecx
push edx
mov  ebx,10
xor  ecx,ecx
 
;--- Divisions par 10 successives pour obtenir un résultat affichable
xor  eax,eax
lodsw
BcleAscii:
xor  edx,edx ; edx = 0 (car c'est la partie haute du dividende)
div  ebx		; division par 10 de EDX:EAX
push edx		; on stocke le reste en pile
inc  ecx		; on compte le nombre d'empilages
cmp  eax,0		; si le quotient est nul, on arrête
jne  BcleAscii
 
;--- Restitution de la pile dans le buffer
BcleBuffer:
pop  eax
add  al,30h	; conversion en ASCII
stosb
loop BcleBuffer
mov  eax,13	; CR
stosb
mov  eax,10	; LF
stosb
pop  edx
pop  ecx
pop  ebx
ret
 
end Start

Bon courage !