Syntaxe code source SpAsm
La puissance du langage 100% assembleur

Retour à l'accueil
SOMMAIRE

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 xIf..xElse..xElseIf..xEndIf:
12 . Les instructions HLLs de boucle xWhile..xEndWhile:
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
Sommaire


02 . 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:
[variables32: 0 256 789 456] ; 4 double-mots initialisés

[variables32: 0 #14] ; 14 double-mots réservés mis à zéro

[variables32: ? #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]
ou
[HECRAN = 600]
* Crochets " [ ] " indispensables !

 Sommaire


07 . Déclaration d'une chaîne de caractères:
[chaîne: 'Bonjour Ami du Web' 0]
ou
[chaîne: 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 xIf..xElse..xElseIf..xEndIf:

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 10 instructions 1If..1Else..1ElseIf..1EndIf à 10If..10Else..10ElseIf..10EndIf.
Leur utilisation est fortement recommandée d'autant que l'incidence sur la vitesse d'exécution du fichier compilé est négligeable.

Exemple1:
1If eax <> ebx ; si eax est différent de ebx mov ecx edx ; exécute cette ligne sinon saute à 1EndIf 2If edx = 256 ; si edx est égal à 256 mov ecx 456 ; exécute cette ligne et saute à 2EndIf sinon saute à 2Else 2Else mov ecx 505 2EndIf 1EndIf Exemple2:
1If edx = 458 ; si edx est égal à 458 mov eax D$variable1 ; exécute cette ligne et saute à 1EndIf sinon saute à 1ElseIf 1ElseIf edx = 589 ; si edx est égal à 589 mov eax D$variable2 ; exécute cette ligne sinon saute à 1EndIf 1EndIf Les conditions de comparaison pour xIf et xElseIf 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 Sommaire


12 . Les instructions HLLs de boucle xWhile..xEndWhile:

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 4 instructions 1While..1EndWhile à 4While..4EndWhile.
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 1While ecx <> 40 ; tant que ecx est différent de 40 add eax 25 ; exécute les instructions entre 1While et 1EndWhile inc ecx 1EndWhile Les conditions de comparaison pour xWhile 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 Sommaire


13 . 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...EndIf 1If ecx <> 40 ; si ecx est différent de 40 add eax 25 ; exécute cette instruction 1EndIf 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 Sommaire


14 . 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.... 1If D@parm2 = 456 Exit 1EndIf 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

A suivre...
Retour à l'accueil
Vos remarques et suggestions sont les bienvenues
AsmGges @2003