Discussion :

[nobie]

j'ai un fichier addition.txt dans le contenu est nb1+nb2= "ex 124+23=" max 20 caractères
et je doit afficher a l'écran le résultat de l'addition "ex 124+23=147"

mais je sait pas comme on peut lire a partir de mon fichier


Gros MErci

[Noteworthy]

Bonjour nobie, je m'exuce pour le retard,

Le principe de l’algorithme est le suivant :
-Ouverture du fichier.
-Lecture du fichier

• Lire les x caractères du fichier et les mettre dans une zone mémoire prévue pour cet usage jusqu’as x = ’0’

• Récupérer la poigné du fichier (hundle), afin que, au cas où plusieurs fichiers à été ouverts par ton programme, chacun a une poigné différente permet à ton programme de les distinguer, en fait toutes les interruptions qui travaillent sur les fichiers en ont besoin dans le registre BX.

• Faire l’addition.

• Afficher à l’écran le résultat.

-Fermer le fichier.

Si nous détaillons :

• Ouverture du fichier par l’appel de la fonction AH = 3Dh de l’interruption 21h.

AL contient le mode d’accès : 0 pour la lecture, 1 pour l’écriture, 2 pour les deux.
DS : DX pointent sur le nom du fichier, une chaine de caractères terminé par un caractère ASCII de code 0, pour ton cas, c'est 'addition.txt'.
Apres l’appel : le carry flag vaut 1 si le fichier n’existe pas, sinon AX contient le hundle.

• Lecture du fichier par l’appel de la fonction AH = 3Fh de l’interruption 21h.

BX : contient le hundle du fichier.
CX : contient le nombre de caractères à lire.
DS : DX pointent sur le tampon contenant les caractères à écrire.
Apres l’appel : le carry flag vaut 1 si une erreur est survenu , sinon AX contient le nombre de caractères lus.

• Fermeture du fichier par l’appel de la fonction AH = 3Eh de l’interruption 21h.

BX : contient la poigné du fichier.
Apres l’appel : le carry flag vaut 1 si une erreur est survenue, sinon le fichier à été fermé avec succès, c’est équivalent à dire qu’il ne peut plus accéder via son hundle.

mais je sait pas comme on peut lire a partir de mon fichier...

Voilà, nous y sommes. La manipulation des fichiers n’est plus un problème.

D’abord, si tu veux additionner deux nombres de façon que le résultat sera moins de 10, ca ne posera aucun problèmes…
Certes au cas ou le résultat dépasse 10, ou le nombre des caractères n'est pas constant car tu peux écrire "2+124", "20+124", ou bien encore "200+124", tu ne sais pas ou est situé le ‘+’ et le ‘=’ pour savoir quoi additionner, plusieurs cas seront possible.
Dans cette exemple je n’ai traité que si le ‘+’ est positionné à la 2ème place ou la 3ème et le ‘=’ est positionné à la 4ème, la 5ème ou la 6ème.

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
 
.model small
.stack 100h
 
.data
nom_fichier   db "addition.txt", 0
Buffer        db  10 dup (?), "$"
 
 
.code
main proc
mov ax,@data
mov ds,ax
 
;Ouverture et test d’existence du fichier.
mov ah,3dh        ; ouverture du fichier
mov al,0          ; 0:acces en lecture, 1:acces en écriture, 2 pour les deux.
lea dx,nom_fichier; pointent sur le nom du fichier
int 21h       
 
;Lecture du fichier.
mov bx, ax        ; sauvegarde de la poignée  'handle'
lea dx, Buffer    ; contient l'adresse du tampon ou il faut stocker les caracteres lus
mov cx, 20        ; le nombre de caractere à lire '20'
mov ah, 3fh       ; lecture du fichier
int 21h
 
 ;Affichage à l’ecran des caracteres lus.
xor si,si         ; si = 0
xor di,di         ; di = 0
xor bx,bx         ; bx = 0
xor cx,cx         ; cx = 0 
 
suivant :
 
inc di
inc cx
inc si
mov dl , byte ptr [Buffer+si-1]
 
;======================
cmp dl , 0h      
je addition      
 
cmp dl , '+'    
je  plus         
 
cmp dl , '='
je  egal         ;
;======================
 
mov ah , 2
int 21h
jmp suivant
 
 
plus :
push cx         ; sauvegarder la position de '+'
int 21h
jmp suivant
 
 
egal :          ; sauvegarder la position de '='
push di
int 21h
jmp suivant
 
 
 
addition :
 ;Addition des nombres, traitement de cas
 pop di         ; récupérer la valeur de di
 pop cx         ; récupérer la valeur de cx
 
 cmp cx , 2
 je x2 
 
 cmp cx , 3
 je x3
 jmp _fin
 
;========X2===============
x2 : 
cmp di , 4
je x_24
 
cmp di , 5
je x_25
 
cmp di , 6
je x_26
 
jmp _fin
 
x_24 :
mov cl , byte ptr [buffer]
mov dl , byte ptr [buffer+2]
add dl , cl
sub dl , 30h
int 21h
jmp _fin
 
x_25 :
mov bl , byte ptr [buffer]
mov dl , byte ptr [buffer+2]
mov cl , byte ptr [buffer+3]
int 21h
 
add cl , bl
mov dl , cl
sub dl , 30h
int 21h
jmp _fin
 
x_26 :
mov dl , byte ptr [buffer+2]
int 21h
mov dl , byte ptr [buffer+3]
int 21h
 
mov bl , byte ptr [buffer]
mov dl , byte ptr [buffer+4]
add dl , bl
sub dl , 30h
int 21h
jmp _fin
;=========X2==================
 
 
;=========X3==================
x3:
cmp di , 5
je x_35
 
cmp di , 6
je x_36
 
cmp di , 7
je x_37
 
jmp _fin
 
x_35 :
mov dl , byte ptr [buffer]
int 21h
 
mov dl , byte ptr [buffer+1]
mov cl , byte ptr [buffer+3]
add dl , cl
sub dl , 30h
int 21h
jmp _fin
 
x_36 :
mov dl , byte ptr [buffer]
mov cl , byte ptr [buffer+3]
add dl , cl
sub dl , 30h
int 21h
 
mov dl , byte ptr [buffer+1]
mov cl , byte ptr [buffer+4]
add dl , cl
sub dl , 30h
int 21h
jmp _fin
 
x_37 :
mov dl , byte ptr [buffer+3]
int 21h
 
mov dl , byte ptr [buffer]
mov cl , byte ptr [buffer+4]
add dl , cl
sub dl , 30h
int 21h
 
mov dl , byte ptr [buffer+1]
mov cl , byte ptr [buffer+5]
add dl , cl
sub dl , 30h
int 21h
jmp _fin
;=========X3==================
 
_fin :
mov ah, 3eh          ; fermeture du fichier
int 21h
 
 
fin:
mov ah , 00h         ; attendre qu'une touche sois enfoncé pour continuer..
int 16h
 
mov ah , 4ch         ; Rendre la main au DOS
int 21h
 
main endp
end main

Amicalement Noteworthy.