PureBasic permet d’inclure toute commande assembleur x86 (y compris les instructions MMX et FPU) directement dans le code source comme dans un vrai source assembleur. Vous pouvez également utiliser directement les variables ou pointeurs avec les instructions assembleur et pouvez intégrer plusieurs commandes assembleur sur une même ligne.
Sous Windows et Linux, PureBasic utilise fasm (http ://flatassembler.net), alors pour plus d’information à propose de la syntaxe, lire le guide fasm.
Sous OS X, PureBasic utilise yasm (http ://yasm.tortall.net/), alors pour plus d’information à propose de la syntaxe, lire le guide yasm.
Pour utiliser l’assembleur en ligne, utiliser les directives du compilateur EnableASM ou DisableASM . Il est possible d’activer la coloration syntaxique ASM dans l’IDE avec ”Activer la coloration des mots clés assembleur” compiler option .
Règles
Vous devez respecter plusieurs règles précises pour inclure de l’assembleur dans du code PureBasic : - Les variables et les pointeurs doivent être déclarés préalablement à leur utilisation dans un contexte assembleur.
- Concernant les étiquettes (labels) : Les labels référencés en assembleur sont toujours en minuscule. Par exemple, le label ’ETIquette :’ sera transformé en ’l_etiquette’ dans le code assembleur.
Lorsque vous faites référence à un label purebasic dans le corps du programme (en dehors des procedures et des modules) avec des fonctions assembleurs, vous devez précéder son nom par un L minuscule et d’un caractère de soulignement comme ceci ’l_’.
Si le label est défini dans une procédure , alors son préfixe est ’ll_nomprocedure_’, en minuscules (ll comme local label) mais il n’est accessible qu’à l’intérieur de la procédure.
Pour accéder à un label dans un module avec des fonctions assembleurs, vous devez ajouter devant le label le préfixe ’nomdumodule.l_nomprocedure_’ écrit tout en minuscule.
Et enfin un label défini dans une procédure elle-même dans un module s’écrira
’nomdumodule.ll_nomprocedure_’ - Pour info, les listes commencent par ’t_nomlist’, les map par ’m_nommap’ et les tableaux par ’a_nomtableau’ est toujours en minuscule.
Exemple
1 D e c l a r e M o d u l e M o n M o d u l e
2 L a b e l D e c l a r e M o d u l e : ; Son nom a s s e m b l e u r est m o n m o d u l e . l _ l a b e l d e c l a r e m o d u l e :
3 D e c l a r e I n i t () 4 E n d D e c l a r e M o d u l e 5
7 P r o c e d u r e I n i t ()
8 L a b e l M o d u l e P r o c e d u r e : ; Son nom a s s e m b l e u r est m o n m o d u l e . l l _ i n i t _ l a b e l m o d u l e p r o c e d u r e :
9 D e b u g " I n i t F e r r a r i () "
10 E n d P r o c e d u r e
11
12 L a b e l M o d u l e 1 : ; Son nom a s s e m b l e u r est m o n m o d u l e . l _ l a b e l m o d u l e 1 :
13 E n d M o d u l e 14
15 P r o c e d u r e T e s t (* Pointer , V a r i a b l e )
16 T o k i S T A R T : ; Son nom a s s e m b l e u r est l l _ t e s t _ t o k i s t a r t :
17
18 ! MOV d w o r d [ p . p _ P o i n t e r ] , 20 19 ! MOV d w o r d [ p . v _ V a r i a b l e ] , 30
20 D e b u g * P o i n t e r ; Son nom a s s e m b l e u r est p . p _ P o i n t e r
21 D e b u g V a r i a b l e ; Son nom a s s e m b l e u r est p . v _ V a r i a b l e
22 E n d P r o c e d u r e
23
24 VAR =1 ; Son nom a s s e m b l e u r est v _ V A R
25 * P o i n t t =A l l o c a t e M e m o r y( 1 0 ) ; Son nom a s s e m b l e u r est p _ P o i n t t
26
27 M o n M o d u l e :: I n i t () 28 T e s t (0 ,0)
29
30 L a b e l 1 : ; Son nom a s s e m b l e u r est l _ l a b e l 1 :
31 ! jmp l _ l a b e l e n d ; Une i n s t r u c t i o n en a s s e m b l e r d o i t s u i v r e les r è g l e s ci - d e s s u s . Ici c ’ est l _ n o m e l a b e l
32 ; ...
33 L a b e l E n d : ; Son nom a s s e m b l e u r est l _ l a b e l e n d :
- Les erreurs dans une section asm ne sont pas reportées par PureBasic mais par Fasm. Vérifiez votre code si une telle erreur survient.
- Avec l’assembleur en ligne activé, vous ne pouvez pas utiliser les mots clés ASM pour les étiquettes (label).
- Sur les processeurs x86, les registres volatiles sont : eax, ecx, edx, xmm0, xmm1, xmm2 et xmm3. Tous les autres doivent être préservés.
- Sur les processeurs x64, les registres volatiles sont : rax, rcx, rdx, r8, r9, xmm0, xmm1, xmm2 et xmm3. Tous les autres doivent être préservés.
- Windows : un fichier aide-ASM peut être téléchargé ici. Si vous déplacez le fichier ’ASM.HLP’ dans le dossier ’Help/’ de PureBasic, vous aurez accès à l’aide sur les mots clés assembleur en appuyant sur F1. (Note : Ne fonctionne que si l’option ’assembleur en ligne’ est activé).
Quand on utilise l’assembleur dans une procédure , il est utile de connaître les points suivants :
- Pour renvoyer directement la valeur du registre ’eax’ (ou ’rax’ sur x64)comme valeur de retour, il suffit d’utiliser ProcedureReturn, sans paramètre. Le contenu du registre ’eax’ (ou ’rax’ sur x64) restera inchangé et sera utilisé comme valeur de retour.
Exemple
1 P r o c e d u r e. l M o n T e s t () 2 ! MOV eax , 45 3 P r o c e d u r e R e t u r n ; La v a l e u r de r e t o u r s e r a 45 4 E n d P r o c e d u r e 5 D e b u g M o n T e s t ()- Les variables locales en PureBasic sont directement indexées par rapport au registre de la pile (ESP) ce qui implique qu’un changement de la valeur de ce registre par une instruction assembleur (tel que PUSH, POP etc..) la référence vers la variable ne sera plus correcte.
- Il est possible de passer directement une ligne complète à l’assembleur sans aucune modification en utilisant le caractère ’ !’ en début de ligne. Ceci permet d’avoir un accès total aux fonctionnalités de l’assembleur. Pour faciliter l’accès aux variables locales, une notation a été mise en place :
’p.v_NomVariable’ pour une variable standard et ’p.p_NomPointeur’ pour un pointeur.
Exemple
1 P r o c e d u r e T e s t (* Pointer , V a r i a b l e ) 2 ! MOV d w o r d [ p . p _ P o i n t e r ] , 20 3 ! MOV d w o r d [ p . v _ V a r i a b l e ] , 30 4 D e b u g * P o i n t e r 5 D e b u g V a r i a b l e 6 E n d P r o c e d u r e 7 8 T e s t (0 , 0)Chapitre 41
Interfaces
Syntax
I n t e r f a c e < nom > [E x t e n d s < nom >] < M e t h o d e [. < type > ] ( ) > ... E n d I n t e r f a c eDescription
Les Interfaces sont utilisées pour accéder facilement aux modules ’Orientés Objets’ tels que les bibliothèques COM (Component Object Model) ou DirectX. Ce type de bibliothèques sont de plus en plus courantes sous Windows et les interfaces permettent une exploitation de ces fonctions sans impacts de performances. Les interfaces jettent aussi les bases pour une ’Programmation Orientée Object’ (OOP en anglais) avec PureBasic mais de solides connaissances sont nécessaires pour en tirer parti (les
interfaces n’ont pas été conçues pour ajouter une couche objet à PureBasic mais plutôt pour accéder facilement à des objets dejà conçus). La plupart des interfaces utilisées sous Windows sont déjà incluses dans les fichiers résidents ’Interfaces.res’ et ’InterfaceDX.res’, ce qui rend leur utilisation immédiate. Le paramètre optionnelExtendspermet d’étendre une interface sans avoir à dupliquer ses fonctions (ces ’fonctions’ sont aussi communément appelées ’méthodes’ dans les autres langages objet tels que C++ ou Java). Toutes les fonctions contenues dans l’interface étendue seront disponibles dans la nouvelle
interface. C’est utile pour un héritage simple d’objets.
les tableaux (Arrays) peuvent être passés en paramètres à l’aide du mot cléArray, Les listes en utilisant le mot cléListet les maps en utilisant le mot cléMap.
Un type de retour peut être défini dans la déclaration de l’interface en ajoutant le type après la méthode. La commande SizeOf peut être utilisée avec les interfaces pour déterminer la taille d’une interface et la commande OffsetOf peut être utilisée pour déterminer l’index d’une fonction dans une interface. Les pseudotypes peuvent être utilisés pour les paramètres des fonctions de l’interface, mais pas pour le type de retour.
Note : Les concepts objets sont principalement appropriés pour les développeurs expérimentés et il n’est pas nécessaire de les maîtriser ou même les comprendre pour réaliser des applications ou jeux
professionnels.