Comparaison de deux chiffres en asmx86

Version imprimable

Bonjour je débute juste en assembleur et je souhaiterais réalisé un programme simple qui compare deux chiffres et affiche si ils sont égaux ou différents :

Voila se que j'ai codé qui ne fonctionne pas :
Code:

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 org 0x0100 mov ax, var1 mov bx, var2 cmp bx, ax jz equal jne not_equal equal : mov dx, msg1 mov ah, 0x9 int 21h ret not_equal : mov dx, msg2 mov ah, 0x9 int 21h ret compare : db "compare deux nombre entier :", 10, 13, '$' msg1: db "Les chiffre sont les meme", 10, 13, '$' msg2: db "Les chiffres sont different", 10, 13, '$' var1 db 4 var2 db 3
Merci d'avance pour vote aide

15/03/2018, 17h19
Forthman

Salut,

Je remarque 2 choses :

Certains assembleurs ont besoin de crochets pour spécifier le contenu d'une adresse.
Donc peut-être avec [var1] au lieu de var tout seul

2eme chose, et là je suis sûr que ça doit foutre la merde : tes variables sont définies en byte, et tu places les valeurs dans des registres 16 bits.
donc utilises dw plutôt que db pour définir tes variables

3eme chose qui ne pose pas de problème, mais qui est "moche" : l'utilisation de jz et jne, soit deux sauts conditionnels opposés.
en fait, tu n'as pas besoin de jne, mais tu devrais plutôt inverser les parties du code "égal"/"pas égal" (si ça n'est pas égal ça va continuer après jz)

dis nous si ça fonctionne ;)
15/03/2018, 17h25
Kannagi

Ah du bon vieux x86-16bits sous MS-DOS...
Personnellement je te conseille de changer de plateforme.

Bref pour ton code tu as fait 2 erreurs :
1)Tu ne fait pas la différence entre une valeur immédiate et une adresse mémoire , quand tu écris mov ax,var1 c'est pour les valeurs immédiate , tu dis que ax et égal a l'adresse de var1 , on va dire que l’adresse de var1 c'est 0x150 , donc ax est égal a 0x150 et bx est égal à 0x151 et voila les deux seront toujours différents !
2) mov ax et mov ,bx lise en 16 bits , et db signifie que tu écrits sut 1 octet...
Donc je vais pas te donner la réponse toute faite (chez moi après modif le code marche) , tu dois mettre entre [] pour lire une adresse mémoire (ou l'écrire).
Ensuite dw c'est pour écrire en word (donc en 16 bits).

PS:Ah mince Forthman est plus rapide que moi :D
Sinon tu dis certain assembleur , ce n'est pas une 'norme' pour le x86 , pour valeur immédiate et adresse mémoire entre crochet ?
Effectivement pour d'autre plateforme que le x86 , c'est le # pour les valeurs immédiates , et sans caractere spécifique pour les adresses mémoires.
(Mais bon c'est juste des histoires de syntaxes rien n'oblige aux programmes assembleurs de les respecter).

Un grand merci a vous et vos explications très clair et limpide, j'y suis donc arrivé.

Voici le code :
Code:

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 org 0x0100 mov ax, [var1] mov bx, [var2] cmp bx, ax jz equal not_equal : mov dx, msg2 mov ah, 0x9 int 21h ret equal : mov dx, msg1 mov ah, 0x9 int 21h ret compare : db "compare deux nombre entier :", 10, 13, '$' msg1: db "Les chiffre sont les meme", 10, 13, '$' msg2: db "Les chiffres sont different", 10, 13, '$' var1 dw 2 var2 dw 2
C'est correct là non ?

Et si je veux afficher ça comme resultat : "le chiffre var1 est le même que var2", vous avez une piste me donner car je galère un peu ....

Citation:

Ah du bon vieux x86-16bits sous MS-DOS...
Personnellement je te conseille de changer de plateforme.

Je suis sous Ubuntu avec une dosBox c'est pas bon comme façon de faire ?

15/03/2018, 19h24
Kannagi

Ton code est bon oui.

Ben sur MS-DOS , je connais pas vraiment si il y'a un truc tout fait , sinon go recoder la fonction printf ;)
Si c'est vraiment un truc statique pourquoi pas utiliser ton code actuelle genre : msg3: db "le chiffre var1 est le même que var2", 10, 13, '$'

Et ça revient à ta deuxieme question , pourquoi faire du MS-DOS et non un code assembleur sur Linux x86-64 bits ?
Tu pourra au moins utilisé la lib C. (Après l’intérêt du truc...).
16/03/2018, 11h22
Forthman

non, rien de prémâché sous DOS pour afficher une valeur. mais c'est un code simple à faire, et il doit traîner des exemples un peu partout :P

Quand à l'utilité de faire de l'assembleur sous DOS... moi j'en fais encore (pareil avec DosBox ou directement sur une vieille machine qui tourne sous freeDos
Je l'utilise pour des petites applications autonomes.
En début d'année j'ai fait une pendule pour mon atelier avec une eeebox et un écran 15 pouces de récup

L'avantage c'est que ça démarre super vite, et qu'en cas de coupure de courant ça ne risque rien :aie: (et la nostalgie aussi, ça compte :oops:)
16/03/2018, 14h40
Kannagi

Citation:

Envoyé par Forthman

directement sur une vieille machine qui tourne sous freeDos
[...]
(et la nostalgie aussi, ça compte :oops:)

Totalement d'accord sur ce point (de meme pour la nostalgie) , mais justement je ne suis pas sur qu'il test sur une vrai machine (enfin pour moi tester son code sur une vrai machine de temps en temps est assez primordiale ! ) , les émulateurs ne sont jamais extrêmement précis.
Par exemple les émulateurs des consoles de 6 eme génération n'émule pas le cache , du coup j'ai eu quelque surprise quand j'ai oublié de flush les données :D

Affichage des nombres en format décimal

Juste une proposition de complément pour ton programme car j'ai cru comprendre (peut-être à tort) que tu souhaitais un affichage des nombres en format décimal classique...
Problème : je n'ai rien testé...
Essaie d'abandonner le DOS pour Windows. Mais c'est vrai : faut s'accrocher aux branches pour coder le moindre truc!

Code:

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
org 0x0100
 
mov ax, [var1]
mov bx, [var2]
cmp bx, ax
jz  equal
 
not_equal :
mov dx, msg2
mov ah, 0x9
int 21h
jmp FinProg
 
;---- Nouveau message avec affichage des nombres en décimal 
equal :
 
mov dx, msg3a
mov ah, 0x9
int 21h
 
mov ax, var1
mov di,offset var1str
call Conv_DEC
 
mov dx, msg3b
mov ah, 0x9
int 21h
 
mov ax, var2
mov di,offset var2str
call Conv_DEC
 
;--- Fin "propre" du programme
FinProg :
mov ax, 4C00h
int 21h
 
;----- Conversion en décimal et affichage
; Le nombre est affiché dans un mot. Il peut donc comporter
; 5 chiffres au maximum.
Conv_DEC :
push di
xor cx,cx      ; compteur d'empilage
BcleDiv :
xor dx,dx
mov bx, 10
div bx         ; DX:AX = dividende, AX = quotient, DX = reste
push dx
inc cx
or ax,ax       ; division terminée ?
jnz BcleDiv
 
cld                ; incrémentation auto de DI pour STOSB
BcleNb :
pop ax
add al,30h     ; chiffre en ASCII
stosb
loopnz BcleNb
mov al,’$’
stosb
 
pop dx          ; récupération du début de la chaîne
mov ah, 0x9
int 21h
ret
 
 
compare : db "compare deux nombre entier :", 10, 13, '$'
msg1: db "Les chiffre sont les meme", 10, 13, '$'
msg2: db "Les chiffres sont different", 10, 13, '$'
 
msg3a: db "Le nombre $'
var1str db 7 dup(0)
msg3b: db " est le même que $'
var2str db 7 dup(0)
 
var1 	dw	2
var2	dw	2