J'apprends la programmation avec l'assembleur x86, partie 3

On va afiicher l'alphabet dans notre console. Il s'agit toujours d'afficher du texte, mais avec un twist... enfin une loop !

Les jours et l'ennui de China Blue

Pour parvenir à notre résultat, on pourrait se contenter du code suivant :

org 0x100

global main

section .text

main:
    mov ah, 0x09        ; service pour afficher un texte
    mov dx, alphabet    ; dx pointe sur l'alphabet
    int 0x21            ; on affiche

    mov ax, 0x4c00      ; on quitte sans erreur
    int 0x21

section .data
alphabet db 'ABCDEFGHIJKLMNOPQRSTUVWXYZ$'

Mais où le fun dans ce programme ?
Ça fonctionne, mais nous n'avons rien appris de neuf et on s'est grâve ennuyés.

Avec les boucles, on va pouvoir faire la même chose de manière bien plus élégante !

Tu m'as pas loopé...

Pour arriver à notre résultat, on va afficher un par un les caractères de l'alphabet en partant du code ASCII de la lettre 'A' jusqu'à celui de la lettre 'Z'.
Nous allons utiliser une boucle dont la syntaxe est :

loop debut_de_la_boucle

• loop va rejoindre le début de la boucle tant que le compteur de boucle, qui est toujours cx est supérieur à 0.
• debut_de_la_boucle est le point du programme à atteindre. C'est un label tout comme le main: que l'on utilise depuis le début de nos tutos.

Ainsi si on écrit :

    mov cx, 10
debut_boucle:
    mov ax, 20
    loop debut_boucle

l'instruction mov ax,20 sera exécutée 10 fois car chaque appel à loop enlève 1 à la valeur de cx : cx est décrémenté de 1.

C'est super important d'assigner la valeur de cx hors de la boucle, sinon cx reprendra la valeur de 10 à chaque itération. Le programme ne sortira jamais de cette boucle infinie.

Quel sacré caractère !

On va ainsi boucler 26 fois de la lettre 'A' à la lettre 'Z' et afficher à chaque fois le caractère. On initialisera cx :

mov cx, 26

ou encore mieux :

mov cx, 'Z'-'A'+1   ; code ASCII de Z (90) - code ASCII de A (65) + 1 = 26

Le service 0x02 de l'interruption 0x21 nous permet d'afficher un caractère à la fois, la code ASCII du caractère étant placé dans le registre dl.
Par exemple pour afficher '@' on fera :

mov ah, 0x02
mov dl, '@'
int 0x21

Plus qu'à écrire le programme !

Le code source de alphabet.asm

; ========
; alphabet
; ========
;
; C:\nasm -fbin alphabet.asm -o alphabet.com

org 0x100

global main

section .text

main:
    mov ah, 0x02        ; le service 0x02 affiche un caractère à la fois
    mov dl, 'A'         ; dl est le code ASCII du caractère
    mov cx, 'Z'-'A'+1   ; cx est notre compteur
afficher:
    int 0x21            ; on affiche
    inc dl              ; on passe au caractère suivant
    loop afficher       ; et on recommence tant que cx est > 0

    mov ax, 0x4c00      ; on quitte sans erreur
    int 0x21

On compile :

C:\nasm -fbin alphabet.asm -o alphabet.com

On exécute :

C:\alphabet

Et voici le résultat :

ABCDEFGHIJKLMNOPQRSTUVWXYZ
C:\_

Pour m'entrainer

Afficher l'alphabet dans le sens inverse, de 'Z' à 'A'.
(l'inverse de l'instruction inc est dec)

org 0x100   

global main     

section .text   

main:
    mov ah, 0x02
    mov dl, 'Z'
    mov cx, 'Z' - 'A' + 1
rehciffa:
    int 0x21
    dec dl
    loop rehciffa

    mov ax, 0x4c00          
    int 0x21

Et après...

Lire la partie 4 dans laquelle on va écrire en mémoire !