A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
ASSEMBLAGE (Phase d') :
Il s'agit en fait de savoir comment créer un programme à partir d'un fichier texte nommé *.asm
Voilà, vous avez un fichier nommé : ESSAI.ASM
Certains auront en plus un fichier de resource:
- il peut prendre le même nom que son fichier ESSAI.RC
- Ou bien un nom défini par défaut RSRC.RC
Ces deux fichiers (ou bien seulement ESSAI.ASM si il n'a pas de ressources) doivent êtres placés dans un dossier où se trouvent aussi
les fichiers suivants:
- ML.exe
- RC.exe (+Rcdll.dll)
- LINK.exe (+Mspdb50.dll)
ensuite il suffit d'écrire sous dos:
C:\......\ml /c /coff /Cp ESSAI.ASM
C:\......\rc ESSAI.RC (ou bien : rc RSRC.RC)
C:\......\link /SUBSYSTEM:WINDOWS /LIBPATH:c:\masm32\lib ESSAI.obj ESSAI.res
(ou bien RSRC.res) Attention à ce 'c', si vous avez installés masm32 sur d: devinez ce que vous devez faire.
Pour vous aider, j'ai automatisé tout ça dans un petit programme en *.bat qui s'appelle 'Assemble_le.bat'. Il s'occupera de tout pour vous, à cette condition près: Vous installez masm32 sur c: et créer votre sous dossier
spécial assemblage (peu importe son nom) sous masm32. Ce qui pour moi donne c:\masm32\_essai\ Dans ce dossier vous devez forcément mettre ml, rc, link, Cvtres et les deux dll.
Placez y aussi Assemble_le.bat et votre fichier à assembler sous le nom unique de essai.asm, si vous avez un fichier de ressource en plus il doit aussi s'y trouver et s'appelé essai.rc ou rsrc.rc.
Le même processus peut être entrepris pour ASSEMBLER UNE DLL.
CHILD WINDOW :
Voir 'Control'.
Classe de fenêtre
Voir 'Window Class'
COMMAND LINE
Le paramètre lpCmdLine est un pointeur vers la ligne de commande ayant executé l'application
(du style "c:\monapp.exe /v"), ce qui est utile pour récupérer des paramètres en ligne de commande.
Vous obtiendrez ce pointeur en appelant la fonction GetCommandLineA.
(info pêchée dans un Tut sur Nasm d'X-or)
Control
Control n'est pas une traduction du mot français Contrôle, rien à voir. Un Control est un objet.
Par exemple vous avez créé votre fenêtre principale, si vous y ajoutez une boite de saisie de texte, des boutons,
une barre de scrolling verticale et horizontale (pour faire défiler un texte plus grand qu'une page), tout
ça sont des 'Controls' ou bien des 'Child Window'. D'ailleurs, dans certains tuts vous trouverez: 'Child Window Controls'.
Donc quand on parle d'un 'Child Window' ou une 'Fenêtre Enfant' ce n'est pas une fenêtre comme on l'entend de la même
manière que notre fenêtre principale mais c'est un objet quelconque un 'Control' qui est commandé par une
vraie fenêtre ou bien même un autre Control mais de plus haute autorité. Comme la 'fenêtre principale' est dite 'la
fenêtre parente' de tous les sous objets tels que les boutons qui la composent... qui sont ses objets enfants ou ses
'Child Window'
handle
Sachez qu'un handle est une sorte d'index dans un tableau contenant des caractèristiques.
Ici windows tient un tableau d'info sur le programme et notre numéro d'handle lui permet de savoir ou
regarder dans son tableau pour avoir le numéro qu'on lui donne.
(info pêchée dans un Tut sur Nasm d'X-or)
Chaque objet possède son propre et unique Handle, la fenêtre principale ses fenêtres enfants, les boutons
les boîtes d'édition...etc. Un Handle, c'est le n° qui sert à faire appel à un objet. Un programme se sert
des handles pour savoir comment sont liés les objets les uns par rapport aux autres. Par exemple une fenêtre
pincipale portant le Handle=0054 ouvre une MessageBox qui aura comme dernier paramètre 0054 qui représente
le handle de son parent. Ainsi on sait a qui appartient cette MessageBox.
Si on a récupéré du texte dans un Buffer (un espace de mémoire pour stocker des infos) et qu'on
souhaite envoyer ce texte vers un receveur, par exemple une boîte d'édition, une fenêtre fille, ou un bouton
ou la fenêtre principale, Alors on doit envoyer ce texte vers le Handle du bouton pour que le texte de ce bouton
soit remplacé par le nouveau. Sans Handle, ce texte n'aurait pas su à quel objet il était destiné.
hInstance
Le paramètre hInstance est un nombre identifiant le programme en cours d'execution. hInstance signifie
'handle Instance', sachez qu'un handle est une sorte d'index dans un tableau contenant des caractèristiques.
Ici windows tient un tableau d'info sur le programme et notre numéro d'handle lui permet de savoir ou
regarder dans son tableau pour avoir le numéro qu'on lui donne. Vous pouvez l'obtenir en appelant la
fonction GetModuleHandleA qui renvoie l'Handle (nb) correspondant à la tache en cours. Notez que sous
win32, Handle=hInstance.
(info pêchée dans un Tut sur Nasm d'X-or)
HUTCH : Le hutch est l'ensemble des fichiers *.inc . Tous les fichiers INCLUDE font parti du hutch.
-------------------------------------------------------
| THE HUTCH |
| |
| |--------------------------------------------| |
| | Fichier INCLUDE n°1 (extension *.inc) | |
| |--------------------------------------------| |
| |
| |--------------------------------------------| |
| | Fichier INCLUDE n°2, n°3, n°4, n°...etc | |
| |--------------------------------------------| |
| |
| |
| |--------------------------------------------| |
| | Windows.inc est aussi un fichier | |
| | INCLUDE (c'est le principal fichier du hutch) | |
| |--------------------------------------------| |
| |
-------------------------------------------------------
MOT : (Le mot de poids faible ou de poids fort)
Par exemple si LParam est une variable de 32 bit (un DWord)
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
et qu'on rempli le mot (the Word donc 16 bit) de poids fort de LParam on aura ça:
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Si au contraire on avait rempli le mot de poids faible de LParam on aurait eu ceci:
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
En fait, quand on change la valeur du mot de poids fort de LParam, on ne met pas que des 1 mais une suite de 1 et de 0, mais surtout ça signifie qu'on ne touche en aucun cas à sa partie basse. Et inversement.
PROCEDURE (de fenêtre, de messages, de debugging<-- j'arrive pas à traduire ça) :
La 'procédure de fenêtre' est la procédure principale de notre programme. En fait, c'est un bout de code
qui forme une boucle sur lui-même et qui s'occupe d'afficher tous les éléments à l'intérieur de notre
fenêtre (il gère les boutons...)
La 'procédure de messages' c'est en fait aussi la même chose mais en plus, on fait en sorte qu'elle s'occupe
de traiter des messages quand l'un d'eux lui parvient. Ex: Si on clique sur le bouton, elle le détecte et on
peut utiliser cette information.
La 'procédure de debugging' c'est encore pareil, c'est une procédure de messages quelconque à ceci prêt que les
seuls messages qui nous intéressent dans ce cas sont des messages provoqués par des événement qui sont spécifiques
à tous ce qui touche le débogage. (Genre : Ouverture d'un nouveau lien, création d'un process, lire ou écrire
dans un octet d'un autre programme...etc)
PROTOTYPE DE FONCTION : Le prototype d'une fonction n'est en aucun cas une instruction du language Assembleur. ça n'a rien à voir avec des instructions comme 'Mov', 'Push', 'Call'...
c'est simplement une notice pour qu'on sache comment utiliser une fonction. Mais jamais on écrira un prototype de fonction dans le programme lui-même.
Exemple: Le 'Prototype de Fonction' de 'ExitProcess' est ExitProcess proto uExitCode:DWORD. ce qui signifie que la fonction ExitProcess s'utilise avec une seule valeur de type Dword. D'après ce qu'on vient d'appendre de son prototype de fonction juste au-dessus, vous devrez écrire dans votre programme un truc dans le genre :
invoke ExitProcess, 0 (Si vous faites appelle à un fichier INCLUDE)
Ou bien:
Push 0 (Si vous ne faites pas appelle à un fichier INCLUDE)
Call ExitProcess (ça, c'est de l'assembleur tout ce qu'il y a de plus classique)
WINDOW CLASS :
Une classe de fenetre est une structure WNDCLASSEX (EX pour extended, vous pouvez utiliser la structure
WNDCLASS mais elle propose moins d'options) contenant toutes les informations concernant la fenetre : sa
taille, ses attributs, la fonction chargée de gérer les messages qui lui sont envoyés, etc... Vous
commencez donc par la remplir.
Ensuite, vous l'enregistrez avec la fonction RegisterClassExA (respectivement RegisterClass), vous créez
la fenetre avec la fonction CreateWindowExA, vous l'affichez avec la fonction ShowWindow et vous rentrez
dans la boucle des messages. Cette dernière est arrêtée par l'envoi d'un message de fermeture à
l'application. Le rôle de cette boucle est de demander à windows de lui envoyer un message de la liste
d'attente (par la fonction GetMessageA), de le traduire (par la fonction TranslateMessage qui par exemple
traduit les scan codes du clavier en codes ASCII) et de l'envoyer à la fenetre de l'application à laquelle
elle est destinée (par la fonction DispatchMessageA).
(info pêchée dans un Tut sur Nasm d'X-or)