|
01 . Forme d'une instruction: 02 . Déclaration d'une variable 8bits: 03 . Déclaration d'une variable 16bits: 04 . Déclaration d'une variable 32bits: 05 . Réservation de plusieurs variables 32bits: 06 . Déclaration d'une constante: 07 . Déclaration d'une chaîne de caractères: 08 . Accès à l'ADRESSE d'une variable: 09 . Accès au CONTENU d'une variable: 10 . Accès au CONTENU d'une variable avec déplacement: 11 . Les instructions HLLs .If .Else .ElseIf .EndIf: 12 . Les instructions HLLs de boucle .While .EndWhile: 13 . L'instruction HLLs de condition On: 14 . Les Procédures ou sous-programmes: 15 . Les variables globales et les variales locales: 01 . Forme d'une instruction:
mov eax ebx
;ou
mov eax,ebx
Les virgules ne sont pas indispensables sauf dans le cas d'une valeur négative
mov eax,-789
;ou sans virgule
mov eax 0-789
Sommaire02 . Déclaration d'une variable 8bits:
[Variable8: B$ 89]
* Crochets " [ ] " indispensables !Sommaire 03 . Déclaration d'une variable 16bits:
[Variable16: W$ 1230]
* Crochets " [ ] " indispensables !Sommaire 04 . Déclaration d'une variable 32bits:
[Variable32: D$ 178900]
;ou
[Variable32: 178900]
Si la taille " D$ " est omise l'assembleur réserve un double-mot* Crochets " [ ] " indispensables ! Sommaire 05 . Réservation de plusieurs variables 32bits:
[Variables1: 0 256 789 456] ;4 double-mots initialisés
[Variables2: 0 #14] ;14 double-mots réservés mis à zéro
[Variables3: ? #10] ;10 double-mots réservés non initialisés
Si la taille " B$ W$ D$ " est omise l'assembleur réserve des double-mots
[Variables16: W$ 0 #14] ;14 mots réservés mis à zéro
* Crochets " [ ] " indispensables !Sommaire 06 . Déclaration d'une constante:
[HECRAN 600]
* Crochets " [ ] " indispensables !Sommaire 07 . Déclaration d'une chaîne de caractères:
[Chaîne1: 'Bonjour Ami du Web' 0]
[Chaîne2: B$ 'Bonjour Ami du Web' 0]
[Chemin: 'c:\spacegges\bmp\image.bmp' 0]
* Crochets " [ ] " indispensables !Sommaire 08 . Accès à l'ADRESSE d'une variable:
[Var32: D$ 156]
;..........
mov ebx Var32
ebx contient maintenant l'ADRESSE de la variable var32.Sommaire 09 . Accès au CONTENU d'une variable:
[Var32: D$ 156]
;..........
mov ebx D$Var32
ebx contient maintenant le CONTENU 32bits 156 de la variable var32." D$ " en tête de la variable signale à l'assembleur que c'est le CONTENU de la variable qui doit être chargé dans ebx. Sommaire 10 . Accès au CONTENU d'une variable avec déplacement:
[Var32: D$ 156 489 253 764]
;..........
mov ebx Var32
ebx contient maintenant l'ADRESSE de la variable var32.Pour accèder par exemple à la valeur 764 il faut appliquer à ebx le déplacement 3 * 4 octets = 12 et signaler à l'assembleur que c'est le CONTENU de l'adresse qui doit être chargé avec "D$" placé en tête du registre.
mov eax D$ebx+12
;ou
mov eax D$ebx+(3*4)
eax contient maintenant la valeur 764.Sommaire 11 . Les instructions HLLs .If .Else .ElseIf .EndIf: Facilitant grandement la lisibilité et la compréhension du code source ces instructions de comparaison sont définies par l'utilisateur sous la forme de macros présentes dans le code source. Possibilités d'emboîter 9 instructions .If .Else .Else_If .End_If Leur utilisation est fortement recommandée d'autant que l'incidence sur la vitesse d'exécution du fichier compilé est négligeable. Exemple1:
.If eax <> ebx ;si eax est différent de ebx
mov ecx edx ;exécute cette ligne sinon saute à .End_If
.If edx = 256 ;si edx est égal à 256
mov ecx 456 ;exécute cette ligne et saute à .End_If sinon saute à .Else
.Else
mov ecx 505
.End_If
.End_If
Exemple2:
.If edx = 458 ;si edx est égal à 458
mov eax D$variable1 ;exécute cette ligne et saute à .End_If sinon saute à .Else_If
.Else_If edx = 589 ;si edx est égal à 589
mov eax D$variable2 ;exécute cette ligne sinon saute à .End_If
.End_If
Les conditions de comparaison pour .If et .Else_If sont définies par les Equates:
[= e < b > a =< be <= be => ae >= ae <> ne]
<> différent
= égal
< inférieur
> supérieur
<= inférieur ou égal
>= supérieur ou égal
Sommaire12 . Les instructions HLLs de boucle .While .EndWhile: Facilitant grandement la lisibilité et la compréhension du code source ces instructions de boucle sont définies par l'utilisateur sous la forme de macros présentes dans le code source. Possibilités d'emboîter 9 instructions .While .End_While Leur utilisation est fortement recommandée d'autant que l'incidence sur la vitesse d'exécution du fichier compilé est négligeable. Exemple:
mov ecx 0
.While ecx <> 40 ;tant que ecx est différent de 40
add eax 25 ;exécute les instructions entre .While et .End_While
inc ecx
.End_While
Les conditions de comparaison pour .While sont définies par les Equates:
[= e < b > a =< be <= be => ae >= ae <> ne]
<> différent
= égal
< inférieur
> supérieur
<= inférieur ou égal
>= supérieur ou égal
Sommaire13 . L'instruction HLLs de condition On: Facilitant grandement la lisibilité et la compréhension du code source cette instruction de comparaison est définie par l'utilisateur sous la forme de macro présente dans le code source. Son utilisation est fortement recommandée d'autant que l'incidence sur la vitesse d'exécution du fichier compilé est négligeable. Si vous n'avez qu'une seule instruction à exécuter suite à une comparaison l'instruction 'On' permet de tout faire sur une seule ligne. Exemple:
; Comparaison classique avec If...End_If
.If ecx <> 40 ;si ecx est différent de 40
add eax 25 ;exécute cette instruction
.End_If
mov ebx eax ;si ecx = 40 passe directement à cette ligne
; Comparaison avec On
On ecx <> 40, add eax 25 ;si ecx est différent de 40 exécute l'instruction add eax 25
mov ebx eax ;si ecx = 40 passe directement à cette ligne
Les conditions de comparaison pour On sont définies par les Equates:
[= e < b > a =< be <= be => ae >= ae <> ne]
<> différent
= égal
< inférieur
> supérieur
<= inférieur ou égal
>= supérieur ou égal
Sommaire14 . Les Procédures ou sous-programmes: A. Procédure sans paramètre: Appel de la procédure:
call MaProcedure
Composition et déclaration de la procédure:
Proc MaProcedure:
;votre code....
EndP
note: Proc EndP sont des macros définies par l'utilisateur dans le code source.B. Procédure avec paramètres: Appel de la procédure:
call MaProcedure param1 param2 param3
Composition et déclaration de la procédure:
Proc MaProcedure:
Arguments @parm1 @parm2 @parm3
;votre code....
EndP
En tête des paramètres vous devez mettre le symbole " @ ".IMPORTANT: Ces variables déclarées avec " @ " sont des variables LOCALES dont les valeurs ne seront prises en compte qu'à l'intérieur de cette même procédure ! On peut donc utiliser le même nom de variable dans des procédures différentes. A l'intérieur de la procédure le traitement des paramètres est le même que pour des variables globales. La syntaxe de ces variables LOCALES est par exemple:
mov eax D@parm1 ;transfert du CONTENU de la variable locale D@parm1 dans eax
note: Proc Arguments EndP sont des macros définies par l'utilisateur dans le
code source.C. Procédure avec paramètres et autres variables locales: Appel de la procédure:
call MaProcedure param1 param2 param3
Composition et déclaration de la procédure:
Proc MaProcedure:
Arguments @parm1 @parm2 @parm3
Local @varlocal1 @varlocal2
;votre code....
EndP
Si vous avez besoin dans une procédure de variables pour des calculs temporaires ou autres il
faut les déclarer avec " Local ".Comme les paramètres, ces variables ne sont actives et accessibles qu'à l'intérieur de la procédure ou elles sont déclarées. Le traitement et la syntaxe sont identiques aux paramètres. note: Proc Arguments Local EndP sont des macros définies par l'utilisateur dans le code source. D. Quitter prématurement une procédure: Il peut être utile de quitter une procédure avant la rencontre par le pointeur de programme de la macro de fin de procédure " EndP ". On emploie la macro " Exit ".Elle effectue un saut à la macro " EndP " qui récupère l'adresse de retour de l'instruction ayant appellé la procédure,le pointeur de programme se positionnant sur l'instruction suivante.
Proc MaProcedure:
Arguments @parm1 @parm2 @parm3
Local @varlocal1 @varlocal2
;votre code....
.If D@parm2 = 456
Exit
.End_If
;votre code....
EndP
note: Proc Arguments Local Exit EndP sont des macros définies par l'utilisateur dans
le code source.E. Protection des registres du processeur dans une procédure: Si l'on veut utiliser dans la procédure des registres contenant des informations que l'on veut retrouver au retour de la procédure. On peut les sauvegarder avec la macro " Uses ". Cette macro sauvegarde sur la pile les registres concernés et les restaure en fin de procédure.
Proc MaProcedure:
Arguments @parm1 @parm2 @parm3
Local @varlocal1 @varlocal2
Uses eax edx edi
;vous pouvez utilisez les registres eax edx et edi sans perte de donnée....
;votre code....
EndP
note: Proc Arguments Local Uses EndP sont des macros définies par l'utilisateur
dans le code source.F. Autres appels de sous-programmes: On peut passer des paramètres à un sous-programme en employant directement les registres du processeur. Attention à sauvegarder et à restaurer ces registres s'ils contiennent des données à recupérer. Appel du sous-programme:
push eax ebx
mov eax D$variable1
mov ebx 15689
call MonSousProgramme
pop ebx eax
MonSousProgramme:
;votre code....
;utilisation des registres eax et ebx sans perte de donnée...
Ret
note: On peut également passer des paramètres à un sous-programme par la pile .ATTENTION: Sa gestion directe est très délicate !! A réserver aux programmeurs ayant une parfaite connaissance de la sauvegarde/déplacement/restauration du pointeur de la pile. Proc et EndP le font parfaitement et en toute transparence !. Sommaire 15 . Les variables globales et les variales locales: A. Variable Globale
D$VariableGlobale
Cette variable est une variable GLOBALE qui a été définie par
[VariableGlobale: D$ 0] et est accessible depuis
n'importe quel endroit du programme et pendant toute la durée du programme.B. Variable locale
D@VariableLocale
Cette variable est une variable LOCALE qui a été crée et définie par les
macros Arguments ou Local lors de l'appel à une procédure par réservation sur
la pile et n'est accessible et utilisable que dans une procédure, elle est détruite lors de la
rencontre par le pointeur de programme des macros EndP ou Exit provoquant la
sortie de cette procédure.Sommaire |