Difficulté à vérifier le caractère qui a été lu au clavier dans une chaine de ca

Signaler
-
Messages postés
21042
Date d'inscription
jeudi 23 janvier 2003
Statut
Modérateur
Dernière intervention
21 août 2019
-
Bonsoir à tous,
J'ai un petit souci. En fait j'aimerais savoir quel est le caractère que j'ai lu au clavier en comparant la valeur du caractère courant avec les codes ascii correspondants aux caractères. Dans le cas de ce code je teste si c'est le caractère 'a' qui est lu au clavier.
Vous trouverez ci-dessous le code que j'ai pu écrire en ASM

.intel_syntax noprefix
.data
buffer:.space 30,'0'
desc:.asciz "%d\n"
nbcar:.int 0
.global main
main:
        # Lecture de la chaine de caractère        
        push        offset nbcar
        call        lirechaine
        add        esp,4
        push        offset buffer
        push        nbcar
        
        # Traitement de la chaine de caractère
        call        affichechaine
        add        esp,8
        push        0
        call         exit

# fonction permettant de lire une chaine de caractère au clavier
lirechaine:
        push        ebp
        mov        ebp,esp
        mov        eax,3
        mov        ebx,0
        mov        ecx,offset buffer
        mov        edx,30
        int        0x80
        mov        esi,[ebp+8]
        dec        eax
        mov        [esi],eax
        pop        ebp
        ret

# fonction permettant de traiter caractère par caractère de la chaine lue
affichechaine:
        push        ebp
        mov        ebp,esp
        mov        esi,[ebp+8]
        mov        edx,0
tque:        cmp        edx,esi
        je        ftque
        mov        ecx,[ebp+12]        
        add        ecx,edx
        push        ecx
        call        code_caractere
        add        esp,4
        inc        edx
        jmp        tque
ftque:        pop        ebp
        ret

affichecar:
        push        ebp
        mov        ebp,esp
        pusha
        mov        eax,4
        mov        ebx,1
        mov        ecx,[ebp+8]
        mov        edx,1
        int        0x80
        popa
        pop        ebp
        ret

print_int:
        push        ebp
        mov        ebp,esp
        pusha
        push        [ebp+8]
        push        offset desc
        call        printf
        add        esp,8
        popa
        pop        ebp
        ret

code_caractere:
        push        ebp
        mov        ebp,esp
        pusha
        mov        eax,[ebp+8]
        
        #Ici je veux me rassurer de la valeur entière du caractère en cour de traitement
        push        eax
        call        print_int
        add        esp,4
        cmp        eax,98
        je         fin
        
        #Ici je veux me rassurer du caractère en cour de traitement        
        push        eax
        call        affichecar
        add        esp,4
        fin:        popa
        pop        ebp
        ret


Cordialement

2 réponses

Messages postés
559
Date d'inscription
jeudi 28 novembre 2002
Statut
Non membre
Dernière intervention
27 octobre 2020
2
J'ai un petit souci.Oui,mais lequel ?.
Ce genre de code était utile avec le 8086.
les API,les boucles de messages windows sont beaucoup mieux adaptés.
Messages postés
21042
Date d'inscription
jeudi 23 janvier 2003
Statut
Modérateur
Dernière intervention
21 août 2019
24
"lu au clavier", je pense que "tapé sur la console" serait plus proche de la réalité.
admettons que tu as dans EAX le carac en cours, on veut vérifier que est numerique:
sub eax, 48
cmp eax, 9
ja lblNONNUM

ToutEnMasm:
C'est surement un devoir scolaire, on ne va tout de meme pas demander a un prof de suivre l'evolution des technos. Deja que c'est du 32 bits et en syntaxe Intel, suffira jusqu'a sa retraite.

ciao...
BruNews, MVP VC++