3. Le langage

Vous pouvez mettre un, deux ou les trois éléments dans les combinaisons de votre choix mais obligatoirement dans cet ordre. L'instruction est ici au sens large, cela peut être une instruction assembleur, une déclaration, une directive, un appel de macro etc...

Par défaut les nombres sont considérés comme étant en base 10.
Suivi d'un "b", ils sont considérés comme étant en base 2.
Suivi d'un "h", préfixé d'un "$" ou d'un "0x", ils sont considérés comme étant en base 16.
Entre guillemets simples, on prends la valeur du code ascii du caractère.

Les nombres en héxadécimal doivent commencer par un caractère entre 0 et 9. Si ce n'est pas le cas, il faut le préfixer avec un 0.

Les noms peuvent être composés de lettres, de chiffres, d'un '_' ou d'un '@', mais il ne doivent pas commencer par un chiffre. Sam86 n'est pas sensible à la casse. Les labels ne doivent être le nom d'un registre, d'une instruction assembleur ou un mot réservé du langage. (Résultat aleatoire.)

Un label est une référence (un emplacement dans le code) que vous pourrez utilisez pour faire un saut, une affectation, etc... Un label doit être suivi de ':'.
Une variable est une référence à la déclaration de laquel on réserve de la mémoire et pour laquel il y aura un contrôle de la dimension à l'utilisation.

Pour utiliser un label ou une variable, les crochets sont facultatifs. La directive OFFSET permet de mettre en immédiate l'adresse d'une référence.

Réserve un ou plusieurs octets en y associant éventuellement une étiquette. Avec DB vous pouvez mettre un entier 8 bits ou une chaine de caractère.

db 123 var1 db 0D7h, 32h var2 db 'Une chaine de caractère',0

Faîtes bien la différence entre :

abc db 1

¹

abc: db 1

Dans le deuxième cas, abc n'est pas une variable mais un label placé juste avant une réservation sans étiquette.

Avec DW vous pouvez mettre entier 16 bits.

Avec DD vous pouvez mettre un entier 32 bits.

Un contrôle de dimension est effectué à l'utilisation des variables (par exemple : affectation de AX (16 bits)dans var1 (8 bits) => Attention).
En cas "d'erreur" de ce type un message est affiché mais la compilation n'est pas interrompue. Pour éviter l'affichage des messages lors d'imcompatibilité de dimension, on peut écrire :

var db 0D7h mov ax, word [var]

Les deux écritures ci-dessous générent le même code mais celle de gauche émet un warning (attention) car la variable abc n'occupe que 8 bits or EAX est 32 bits. Ces messages n'interrompent pas la compilation. Il est recommandé de ne pas les ignorer car ils peuvent vous éviter des bogues.

abc db 1 mov eax, [abc]

Pas de contrôle => <= Attention !!!

abc: db 1 mov eax, [abc]

Pour le forçage, utilisez byte, word et dword.

abc db 1 mov eax, [abc]

Ok =>

abc db 1 mov eax, dword [abc]

Vous pouvez ne pas afficher les warnings en utilisant les options silencieuses. (cf ligne de commande)

Avec EQU vous pouvez créer des équivalents syntaxiques, ou en d'autre terme, une constante.

Cette directive peut vous éviter d'avoir à modifer 2 fois "5" en "7", le jour où vous voudrez modifier Avec EQU vous pouvez créer des équivalents syntaxiques, ou en d'autre terme, une constante.

Un macro est un outil purement syntaxique qui peut vous éviter d'avoir à recopier plusieurs fois la même suite d'instructionis.

par exemple

beep    MACRO N
        mov      cx, N
@@:     mov      ax, 0E07h        ; Fonction 0Eh, Caractère 7 (Bip)
        int      10h
        loop     @b               ; Saut vers label anonyme précédent
ENDM 

debut:  beep 2                    ; Un programme très original ;)
        nop
        beep 3
        ret
        

include source.asm

INCLUDE ou %INCLUDE vous permet d'insérer à l'endroit de la directives un autre fichier source. (par exemple des bibliothèques de fonctions). Notez bien: le fichier est un texte source.

incbin image.dat

INCBIN ou %INCBIN vous permet d'insérer un fichier binaire dans votre exécutable (par exemple une police ou une image au format brut). Notez bien: le fichier est un binaire.

incrle image.bin

INCRLE fonctionne comme incbin sauf que le fichier est compressé en RLE. (par exemple pour stocker le noyau dans un loader). Notez bien: le fichier est un binaire. L'algorithme de décompression est schématisé ci-dessous.



        ; Code (libre) proposé pour décompresser 
        ; un fichier intégré avec INCRLE par Sam86
        ; Il n'est pas optimisé.


noyau:  incrle  noyau.bin

debut:  cld                            ; pour stosb
        mov     esi, offset noyau      ; Source
        mov     edi, 100000h           ; Destination : premier Mo

boucle: mov     al, [esi]
        inc     esi
        cmp	al, 0FEh
        je      joker

ecritS: mov     [edi], al              ; Écriture Simple
        inc     edi
        jmp     boucle

joker:  xor     ecx, ecx
        mov     cl, [esi]
        inc     esi

        test    cl, cl
        jz      ecritS

        cmp     cl, 1
        je      fin

        btr     cx, 7
        jnc     ecritM
        shl     cx, 8
	mov     cl, [esi]
        inc     esi
        
ecritM: mov     al, [esi]              ; Écriture Multiple
        inc     esi       
        rep stosb
        jmp     boucle        

fin:

 

Utilisez ORG (ou %ORG) pour définir l'adresse à laquelle le code qui suit est censé apparaître en mémoire. Il doit être suivi d'un nombre.

        org     7C00h                  ; Pour écrire un secteur d'amorce par exemple