org 100h

      MOV AH,0Ah
      mov dx, offset INPUT
      INT 21h
      
      
           
      mov ax,[input+2]
      sub al,48
      mov bl,al
      CMP BL,5
      JG LOSE

      MOV AH,09h   
      MOV DX, offset gagne
      INT 21h
      JMP FIN
     
LOSE: MOV AH,09h   
      MOV DX, offset perdu
      INT 21h
      JMP FIN        
     
FIN: RET
INPUT dw '0$'       
gagne db 'winner$'
perdu dw 'You lose$'

bonjour,

Alors ce programme dit que si la valeur input tapez est supérieur à 5 on affiche you lose et si c'est inferieur on affiche winner.

mais le problème est que quand je tape un nombre supérieur ou égale à 10 il m'affiche winner mais normalement il doit m'afficher you lose c est comme si il lit que le 1 er numéro par exemple si je tape 25 il stock que 2 .

Pourriez-vous m'aider à trouver la solution.

Bonsoir.

Déjà la définition de la zone input est bizarre, car si l'utilisateur saisit plus de 4 caractères, la saisie va ecraser les autres zones.

Ensuite tu ne convertit qu'un octet sur les 2 qui peuvent avoir été saisis :

Il faut donc convertir le 1er caractère saisi (en soustrayant 48), le multiplier par 10 puis convertir le deuxème caractère et l'ajouter au résultat précedant pour faire la comparaison.

Mais que se passe-t-il si l'utilisateur saisi 100 ou 1000 ??

Bon courage.

Bon comme l'a dit un intervenant, ne soyons pas mesquin donc voici un exemple de conversion d'une chaine en un nombre entier signé.

C'est une routine pour le compilateur 64 bits nasm mais elle peut s'adapter :

;************************************************************
;     conversion chaine ASCII en entier signé dans registre rax
;************************************************************
; paramètre1  : adresse de la chaine passée par push
; retourne la valeur dans rax
; met le carry à 1 si dépassement de 64 bits
conversionAtoN:
    enter 0,0                 ; prologue
    push rbx                  ;sauvegarde des registres
    push rcx
    push rdx
    push rsi
    push rdi
    mov rsi,[rbp+16]          ; récuperation adresse chaine
    mov rcx,10                ; multiplicateur
    xor rdi,rdi               ; signe positif
    xor rax,rax               ; resultat = 0
    xor rbx,rbx               ; raz registre reception
.A1:                          ; debut de boucle début de chaine
    mov bl,[rsi]              ; lire un caractère
    cmp bl,0                  ; fin de chaine
    je .A100
    cmp bl,0xA                ; fin de ligne
    je .A100
    cmp bl,'-'                ; signe moins
    je .A2
    cmp bl,'+'                ; signe plus éventuel
    je .A3
    cmp bl,' '                ; blanc
    je .A3
    jmp .A4                   ; chiffre
.A2:
    mov rdi,1                 ; signe negatif
.A3:
    inc rsi                   ; caractère suivant
    jmp .A1                   ; et boucle
                              ; traitement des chiffres
.A4:                          ; debut de boucle de conversion des chiffres
    sub bl,48                 ; caractère ASCII -> chiffre 0 à 9
    js .A99                   ; caractere < 0 alors fin de la saisie
    cmp bl,10                 ; caractère > 9  ?
    jge .A99                  ; oui alors fin de la saisie
    mul rcx                   ; multiplie rax par 10
    jo .A98                   ; overflow ?
    add rax,rbx               ; et ajout du nouveau chiffre
    jc  .A98                  ; overflow ?
.A5:
    inc rsi                   ; caractère suivant
    mov bl,[rsi]
    cmp bl,0                  ; fin de chaine
    je .A8
    cmp bl,0xA                ; fin de ligne
    je .A8
    jmp .A4
.A8:
    cmp rdi,0                 ; signe + ?
    je .A99                   ; oui saisie ok
    neg rax                   ; sinon conversion en negatif 
    jmp .A99                  ; saisie Ok
    
.A98:                         ; message overflow
    push szMessDep
    call afficherMessage
    mov rax,0
    stc                       ; pb saisie met le carry à 1
    jmp .A100
.A99:
    clc                       ; saisie ok met le carry à 0
.A100:
    pop rdi
    pop rsi
    pop rdx
    pop rcx
    pop rbx                   ; restaur des registres
    leave                     ; epilogue
    ret 8                     ; alignement pile car 1 push
szMessDep:       db "Dépassement de capacité !!!",10,0

Je suis pas sur que ça lui sera d'une grande aide.
Le PO semble débutant est il fait un code x86-16 bits pour MS-DOS , tu lui propose un code x64 ^^'

Bien sur qu'on peut faire la translation , mais s'il débute ça sera peut être pas si évident

Bonjour.

En effet mais c'est pour faire réfléchir les débutants qui se lancent dans la programmation assembleur 16 bits avec un émulateur msdos (ça date quand même des années 80) alors que l'on peut programmer directement en 64 bits sous windows10 ou linux.

Ah ben le x86 est toujours un vieux processeur , en apparence il reste avec des concept assez ancien.

Après difficile de conseillé l'un ou l'autre.
Avec MS-DOS tu peux taper sur les I/O comme tu veux (et c'est pour moi le principal intérêt de l'asm).
Tu peux faire sûrement mieux qu'un compilo x86-16 bits (surtout que les compilo compte rarement les nombres d'instruction cycle pour les vieux proc , donc il a souvent tendance à pas faire du jolie code).

Par contre le x86 à une façon archaïque de gérer sa mémoire (la segmentation de mémoire) alors que tout les autres proc de l'époque faisait mieux

Et pour le x86-64 bits, ben c'est l'inverse , tu ne peux pas taper sur les I/O ,et le compilo est meilleurs que toi.
Et l'asm sur Windows/Linux se résumé à faire des appels à des syscalls ou d'appel de fonctions (écrite en C...) , en se coltinant en plus des concept de compilateur (call conventions).

Bref j'aurais du mal à conseiller l'un ou l'autre , même si sur MS-DOS tu peux avoir des concept assez bas niveau (bien plus que si tu code sur Windows ou Linux).