Présentation de PureBasic
Date de publication : 11/02/08 , Date de mise à jour : 08/03/08
Par
Comtois
Cet article présente dans les grandes lignes le langage PureBasic qui, malgré sa faible renommée, a tout d'un grand. Nous allons vous aider à mieux le connaitre, et à l'apprécier au cours de nos différents articles.
I. Avant-propos
II. Introduction
III. IDE
III-1. Aide syntaxique
III-2. Pliage
III-3. Auto complétion
III-4. Coloration
III-5. Outils intégrés
III-6. Outils personnalisés
III-7. Préférences
IV. Compilateur
V. Débogueur
VI. Profileur
VII. Le langage
VII-1. Variables
VII-2. Structure
VII-3. Pointeur
VII-4. Pseudotype
VII-5. Prototype
VII-6. Interface
VII-7. Procédure
VII-8. Liste chaînée
VII-9. Macro
VII-10. Import
VII-11. DLL
VIII. API
IX. Bibliothèques
X. Assembleur
XI. Documentations
XII. Liens
XIII. Remerciements
I. Avant-propos
Ce qui suit est issu pour l'essentiel de la documentation PureBasic, quelques exemples proviennent des forums.
II. Introduction
La syntaxe de PureBasic est simple, mais ses possibilités sont infinies grâce à certaines caractéristiques évoluées comme, entre autres, les pointeurs, structures, procédures, listes dynamiques, etc.
Le programmeur expérimenté n'aura aucune difficulté à accéder aux structures du système d'exploitation et aux API's.
III. IDE
L'
IDE est un bon exemple de ce qu'il est possible de coder avec ce langage. Il est compilé avec PureBasic pour les 3 OS Windows, Linux et MacOS.
En dehors des fonctions classiques d'un éditeur de textes, voici une petite liste incomplète des autres fonctionnalités.
III-1. Aide syntaxique
L'IDE affichera les paramètres nécessaires pour chaque fonction PureBasic qui est en cours de frappe. Cela rend plus facile la saisie, en montrant les paramètres qui sont indispensables.
III-2. Pliage
Vous pouvez plier les procédures, les structures, les commentaires, des sections complètes du code, etc. Le choix du pliage s'effectue selon une liste de mots clés configurable.
III-3. Auto complétion
L'auto complétion est très pratique pour éviter de saisir les commandes et les variables, il suffit de taper les premiers caractères, et une liste s'affiche avec les mots possibles. Avec cette fonction vous n'avez plus d'excuse pour ne pas choisir des noms de variables explicites.
III-4. Coloration
Coloration des mots clés, possibilité d'établir sa propre liste de mots clés (Par exemple certains ont développé un outil pour coder dans le style
POO, voir ce
site pour en savoir plus)
III-5. Outils intégrés
Outils intégrés comme la palette des couleurs, le visualisateur de variables, un utilitaire permettant de gérer des modèles de code qui sont souvent utilisés, etc.
III-6. Outils personnalisés
Vous avez la possibilité d'écrire vos propres outils en PureBasic pour effectuer des actions sur le code source en cours d'édition (Réorganisation du code, statistiques, etc).
Voici un exemple de code pour créer un outil avec PureBasic, cet outil permet d'aller chercher une aide sur le site Microsoft, pour le mot se trouvant sous le curseur de l'IDE :
Url.s = "http://search.msdn.microsoft.com/search/results.aspx?view=msdn&st=b&na=82&qu=%mot%&s=1&swc=4"
Mot.s = GetEnvironmentVariable("PB_TOOL_Word")
If Mot
If Right(Mot,1) = "_"
Mot = Left(Mot,Len(Mot)-1)
ElseIf Left(Mot,1) = "#"
Mot = Right(Mot,Len(Mot)-1)
EndIf
RunProgram(ReplaceString(url,"%mot%",Mot))
EndIf
|
Et voici comment configurer l'outil ci-dessus.
III-7. Préférences
L'IDE du PureBasic propose un nombre très conséquent d'options pour qu'il puisse s'adapter aux habitudes des programmeurs qui l'utiliseront. Ces paramètres sont regroupés dans la fenêtre de la commande Préférences du menu "Fichier", et la description de chacune est décrite dans le fichier d'aide de PureBasic.
Si la couleur de fond des images précédentes ne vous convient, pas de souci, vous pourrez la changer aisément.
IV. Compilateur
PureBasic est un compilateur. Il n'utilise donc pas de code intermédiaire ou de machine virtuelle, mais produit un code optimisé directement exécutable par la machine ou le système d'exploitation
sur lequel il est compilé.
V. Débogueur
Le débogueur du PureBasic se présente sous 3 formes:
- Un débogueur intégré directement dans l'IDE, pour une utilisation facile et rapide. C'est ce débogueur qui propose le plus de fonctionnalités.
- Un débogueur indépendant, qui est utile dans plusieurs cas spéciaux (par exemple si le programme est déjà en cours de débuggage et qu'il doit être exécuté une nouvelle fois) ou pour être utilisé par un éditeur de code tierce.
- Un débogueur en ligne de commande uniquement. Le but premier de ce débogueur est de pouvoir tester et développer un programme PureBasic sur un système dépourvu d'environnement graphique (comme un serveur linux), et/ou développer à distance via SSH.
VI. Profileur
Le profileur permet de tracer son programme pour détecter les goulets d'étranglement.
Le nombre de fois que la ligne est exécutée se trouve en abscisse et le numéro des lignes se trouve en ordonnée.

Vue du profileur sans le curseur
VII. Le langage
Voici une série de mots clés de base que je ne vais pas détailler ici. Ils sont pour la plupart courants dans n'importe quel langage BASIC.
Reportez vous à la documentation pour en savoir plus.
- Break : Continue
- For : Next
- ForEach : Next
- Gosub : Return
- If : Else : EndIf
- Repeat : Until
- Select : EndSelect
- While : Wend
- Define
- Dim : ReDim
- Enumeration : EndEnumeration
- NewList
- Structure : EndStructure
- With : EndWith
Passons maintenant à ce qui peut distinguer PureBasic d'un autre BASIC.
VII-1. Variables
| Nom |
Extension |
Encombrement mémoire |
Plage |
| Byte |
.b |
1 octet |
-128 à +127 |
| Caractère |
.c |
1 octet (ascii) |
0 à +255 |
| Caractère |
.c |
2 octet (unicode) |
0 à +65535 |
| Word |
.w |
2 octets |
-32768 à +32767 |
| Long |
.l |
4 octets |
-2147483648 à +2147483647 |
| Float |
.f |
4 octets |
illimité |
| Quad |
.q |
8 octets |
-9223372036854775808 à +9223372036854775807 |
| Double |
.d |
8 octets |
illimité |
| String |
.s |
Longueur de la chaîne + 1 |
illimité |
| String fixe |
.s{longueur} |
Longueur de la chaîne |
illimité |
 |
Les nombres flottants (Simples ou doubles) peuvent être écrits sous la forme: 123.5e-20
|
VII-2. Structure
Une structure est utile pour définir un type utilisateur. Les mots clés Extends, StructureUnion sont également disponibles.
Exemple :
Structure Personne
Nom.s
Prenom.s
Age.w
EndStructure
Dim MesAmis.Personne(100)
MesAmis(0)\Nom = "Durand"
MesAmis(0)\Prenom = "Michel"
MesAmis(0)\Age = 32
|
VII-3. Pointeur
L'utilisation des pointeurs est possible en plaçant une * devant le nom de la variable.
Un pointeur est une variable qui stocke une adresse mémoire, et il est généralement associé à une structure.
Il est possible d'effectuer des opérations arithmétiques sur les pointeurs en s'aidant de la commande SizeOf().
Exemple:
Dim Tableau.Point(1)
*Pointeur.Point = @Tableau()
*Pointeur\x = 10
*Pointeur\y = 15
*Pointeur + SizeOf(Point)
*Pointeur\x = 7
*Pointeur\y = 9
For i = 0 To 1
Debug Tableau(i)\x
Debug Tableau(i)\y
Next i
|
 |
A l'inverse du C/C++, en PureBasic l'* fait partie intégrante du nom de la variable. Aussi ptr et *ptr sont deux variables bien distinctes.
ptr est une variable (régulière) contenant une valeur, *ptr est une autre variable de type pointeur contenant une adresse.
|
VII-4. Pseudotype
Les pseudotypes sont destinés à faciliter la programmation quand l'utilisation de bibliothèques externes nécessitant des types non supportés par PureBasic sont requises. Plusieurs types prédéfinis sont disponibles et permettent une conversion à la volée des types PureBasic vers ces types. Etant donné que ce ne sont pas des types normaux, leur notation est volontairement différente: un préfixe 'p-' (pour 'pseudo') fait partie du nom du type. Les pseudotypes disponibles sont:
- p-ascii: se comporte comme un type 'string', mais la chaîne de caractères sera toujours convertie en ascii lors de l'appel de la fonction, même si le programme est compilé en mode unicode. C'est très utile pour appeler les fonctions d'une bibliothèque qui ne supporte pas l'unicode, dans un programme unicode.
- p-utf8: se comporte comme un type 'string', mais la chaîne de caractères sera toujours convertie en utf-8 lors de l'appel de la fonction. C'est très utile pour appeler les fonctions d'une bibliothèque qui ne supporte que l'utf-8 comme format de chaîne de caractères.
- p-bstr: se comporte comme un type 'string', mais la chaîne de caractères sera toujours convertie en bstr lors de l'appel de la fonction. C'est très utile pour appeler les fonctions d'une bibliothèque qui ont besoin des chaînes de caractères bstr, comme les composants COM.
- p-unicode: se comporte comme un type 'string', mais la chaîne de caractères sera toujours convertie en unicode lors de l'appel de la fonction, même si le programme est compilé en mode ascii. C'est très utile pour appeler les fonctions d'une bibliothèque qui ne supporte que l'unicode, dans un programme ascii.
- p-variant: se comporte comme un type numérique, en ajustant l'appel de la fonction pour utiliser correctement un paramètre de type 'VARIANT'. C'est très utile pour appeler les fonctions d'une bibliothèque qui ont besoin des paramètres de type 'VARIANT', comme les composants COM.
Les pseudotypes peuvent être utilisés uniquement avec les prototypes, les interfaces et les fonctions importées. Ils ne font la conversion que si c'est nécessaire: par exemple utiliser le pseudotype 'p-ascii' dans un programme compilé en mode ascii n'a aucun effet, car les chaînes internes de PureBasic sont déjà en ascii.
VII-5. Prototype
Un Prototype permet la déclaration d'un type particulier qui servira à appeler une fonction. Cela permet de faire facilement des pointeurs de fonctions, car ce type peut être affecté à une variable.
Exemple:
Prototype.l ProtoMessageBox(Fenetre.l, Corps$, Titre$, Options.l = 0)
If OpenLibrary(0, "User32.dll")
MsgBox.ProtoMessageBox = GetFunction(0, "MessageBoxA")
MsgBox(0, "Hello", "World")
EndIf
|
VII-6. Interface
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.
Les interfaces jettent aussi les bases pour une 'Programmation Orientée Objet' (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.
Exemple:
Interface MyObject
Move(x,y)
MoveF(x.f,y.f)
Destroy()
EndInterface
Object1.MyObject = MyCreateObject()
Object2.MyObject = MyCreateObject()
Object1\Move(10, 20)
Object1\Destroy()
Object2\MoveF(10.5, 20.1)
Object2\Destroy()
|
Note : Freak , l'auteur de l'IDE, a développé un
framework pour ceux qui seraient intéressés par le développement d'objets COM.
ComFrameWork
Pour en savoir plus
forum PureBasic
Et pour finir vous trouverez un tutoriel sur les objets COM et PureBasic, il est incomplet et en anglais :
COMTutorial
VII-7. Procédure
Les paramètres en fin de procédure peuvent avoir une valeur par défaut (une expression constante est requise). Les paramètres ayant une valeur par défaut pourront être omis lors de l'appel de la procédure, la valeur par défaut de chaque paramètre manquant sera utilisée.
Une procédure peut également recevoir en paramètre des listes chaînées et des tableaux.
Exemple:
Procedure a(a, b, c=2)
Debug c
EndProcedure
a(10, 12)
a(10, 12, 15)
|
VII-8. Liste chaînée
Les Listes Chaînées (Linked Lists) regroupent des objets qui sont alloués dynamiquement en fonction de vos besoins. Elles se présentent sous la forme de listes d'éléments totalement indépendants les uns des autres. Vous pouvez y ajouter un nombre infini d'éléments, insérer des éléments à une position choisie, en effacer, etc... Cette méthode de stockage d'information est très pratique et très souple.
Exemple :
Structure Personne
Nom.s
Prenom.s
Age.w
EndStructure
NewList MesAmis.Personne()
AddElement(MesAmis())
MesAmis()\Nom = "Durand"
MesAmis()\Prenom = "Michel"
MesAmis()\Age = 32
AddElement(MesAmis())
MesAmis()\Nom = "Dupont"
MesAmis()\Prenom = "François"
MesAmis()\Age = 29
ForEach MesAmis()
Debug MesAmis()\Nom
Debug MesAmis()\Prenom
Debug MesAmis()\Age
Debug "-------------"
Next
|
VII-9. Macro
Les macros sont divisées en deux catégories: les simples (sans paramètre) et les complexes (avec paramètres, obligation d'utiliser les parenthèses pour les appeler). Quand aucun paramètre n'est spécifié, il est possible de remplacer n'importe quel mot avec un autre mot (ou une autre expression). Les macros peuvent être utilisées de manière récursive, mais si un des paramètres passés contient le caractère de concaténation '#', il ne sera pas géré.
Exemple:
Macro XCase(Type, Texte)
Type#Case(Texte)
EndMacro
Debug XCase(U, "Salut")
Debug XCase(L, "Salut")
|
VII-10. Import
Import : EndImport permet de déclarer facilement des fonctions et des variables externes à partir d'un fichier bibliothèque (.lib) ou objet (.obj).
Exemple :
Import "User32.lib"
MessageBoxA(Fenetre.l, Corps$, Titre$, Options.l = 0)
BoiteDeMessage(Fenetre.l, Corps$, Titre$, Options.l) As "_MessageBoxA@16"
EndImport
MessageBoxA(0, "Salut", "le Monde")
BoiteDeMessage(0, "Salut", "le Monde 2", 0)
|
VII-11. DLL
PureBasic permet de créer des librairies dynamiques liées au standard Microsoft Windows. Le code d'une
DLL est de même nature que le code PureBasic excepté qu'aucun code ne peut exister en dehors d'une procédure. Lors de l'écriture d'une DLL, tout le code est intégré dans des procédures. Lorsqu'une procédure doit être publique (accessible par un programme tiers qui doit accéder à la DLL), le mot clef ProcedureDLL est utilisé au lieu de Procedure. C'est la seule différence pour écrire un programme.
Lorsque le codage est ainsi fait, il suffit de sélectionner 'Shared DLL' comme format de sortie (fenêtre 'Compiler Option' dans l'éditeur PureBasic ou commutateur /DLL dans la ligne de commande) et de créer un exécutable.
 |
Sous Linux c'est un fichier .so qui sera créé.
|
Vous trouverez un exemple de création d'une DLL avec PureBasic dans cet
article
VIII. API
La plupart des fonctions de l'
API sont déjà déclarées, ainsi que les structures et constantes.
Ces fonctions sont reconnaissables à l'underscore à la fin du nom de la fonction. Elles sont directement utilisables dans un code PureBasic et vous n'avez rien à déclarer.
Exemple de code utilisant l'API windows (incomplet) :
wc.WNDCLASSEX
wc\cbSize = SizeOf(WNDCLASSEX)
hInstance = GetModuleHandle_(#Null)
If GetClassInfoEx_(hInstance,@"Horloge",@wc) = 0
wc.WNDCLASSEX
wc\cbSize = SizeOf(WNDCLASSEX)
wc\style = #CS_HREDRAW|#CS_VREDRAW|#CS_BYTEALIGNWINDOW
wc\lpfnWndProc = @HorlogeCallback()
wc\hCursor = LoadCursor_(#Null,#IDC_ARROW)
wc\hInstance = hInstance
wc\lpszClassName = @"Horloge"
If RegisterClassEx_(@wc) = 0
End
EndIf
EndIf
hWndMain = CreateWindowEx_($00080088,"Horloge","Horloge",$96000000,50,50,160,160,0,0,hInstance,0)
InvalidateRect_(hWndMain, #Null, #False)
SetTimer_(hWndMain,0,40,0)
While GetMessage_(msg.MSG,#Null,0,0)
TranslateMessage_(msg)
DispatchMessage_(msg)
Wend
|
Exemple de code utilisant gtk sous linux. Ces procédures permettent de contrôler le curseur dans un EditorGadget()
Procedure SetCursorPos(Id.l,pos.l)
Protected mypointertoiteration.GtkTextIter, *buffer.l
*buffer = gtk_text_view_get_buffer_(GadgetID(Id))
gtk_text_buffer_get_iter_at_offset_(*buffer,@mypointertoiteration,pos)
gtk_text_buffer_place_cursor_(*buffer,@mypointertoiteration)
EndProcedure
Procedure.l GetCursorPos(Id.l)
Protected mypointertoiteration.GtkTextIter, *buffer.l,cursor.l
*buffer = gtk_text_view_get_buffer_(GadgetID(Id))
cursor = gtk_text_buffer_get_insert_(*buffer)
gtk_text_buffer_get_iter_at_mark_(*buffer, @mypointertoiteration, cursor)
ProcedureReturn gtk_text_iter_get_offset_(@mypointertoiteration)
EndProcedure
|
Si une fonction manque , il est possible de l'importer facilement :
ImportC "/usr/lib/libgtk-x11-2.0.so"
gtk_print_operation_new()
gtk_print_operation_run(*op, action, *parent, *error)
gtk_print_settings_new()
gtk_print_operation_set_print_settings(*print,*settings)
gtk_print_context_create_pango_layout(*context)
pango_layout_set_text(layout,txt.p-utf8,length)
pango_font_description_from_string(font.p-utf8)
pango_font_description_free(desc)
pango_layout_set_font_description(layout,desc)
cairo_move_to(cr,x,y)
pango_cairo_show_layout(cr,layout)
gtk_print_context_get_cairo_context(context)
gtk_print_operation_set_n_pages(*op,n_pages)
gtk_print_operation_set_unit(*op,unit)
gtk_print_operation_get_status_string (*op)
gtk_print_operation_get_status (*op)
gtk_print_operation_is_finished (*op)
EndImport
|
Je n'ai pas d'exemple sous la main pour Carbon sous MacOS, mais sachez que le principe est le même.
IX. Bibliothèques
PureBasic utilise des bibliothèques externes "tierces" très souples d'emploi. Un programme PureBasic peut faire appel à un nombre illimité de bibliothèques. De nombreuses bibliothèques sont fournies avec la version de base de PureBasic. Seules les portions utiles de bibliothèques utilisées sont incorporées dans le logiciel exécutable final, afin d'obtenir une taille aussi réduite que possible. Elles permettent de gérer les fenêtres, le son, les interfaces graphiques, les sprites, les palettes de couleurs, les réseaux, le tri, le chiffrement, la compression de données, etc.
Parmi les dernières bibliothèques ajoutées à PureBasic , on peut noter :
- Drag and Drop
- Scintilla
- XML
- FTP
- Mail
- HTTP
- Sqlite
- Expression régulière (Utilise
PCRE)
- Gestion Port série
Notes: Tout utilisateur de PureBasic peut créer ses propres bibliothèques. Les outils nécessaires sont fournis avec la version complète. Dans la version PC de PureBasic, les bibliothèques peuvent être écrites en langage C ou assembleur.
Un utilisateur a créé un
utilitaire qui permet de coder ses propres bibliothèques en PureBasic.
Rendez vous sur le
forum PureBasic pour en savoir plus.
X. Assembleur
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. La syntaxe est celle de
FAsm, la lecture du guide FAsm est recommandée si vous souhaitez plus d'informations sur la syntaxe.
Les inconditionnels de l'assembleur pourront compiler leurs programmes PureBasic tout en obtenant le fichier source complet en assembleur commenté du programme compilé, directement recompilable avec l'assembleur Fasm.
Exemple :
Procedure.f WrapAngle(angle.f)
!fldpi
!fadd st0,st0
!fld dword[p.v_angle]
!fprem
!fadd st1,st0
!fldz
!fcomip st1
!fcmovnbe st0,st1
!fstp st1
ProcedureReturn
EndProcedure
Procedure.f WrapAngleDeg(angle.f)
!fild dword[@f]
!fld dword[p.v_angle]
!fprem
!fadd st1,st0
!fldz
!fcomip st1
!fcmovnbe st0,st1
!fstp st1
ProcedureReturn
!@@:dd 360
EndProcedure
|
XI. Documentations
XII. Liens
Forum PureBasic : Rejoignez nous, toutes vos questions ou propositions seront les bienvenues.
Site PureBasic : Téléchargez votre version démo ici plutôt que sur des sites de téléchargement, vous serez sûr d'obtenir la plus à jour.
PureArea.net : Ce site est incontournable, il répertorie tous les sites intéressants concernant PureBasic, ainsi que les utilitaires, bibliothèques, jeux, programmes créés par les utilisateurs, et enfin on peut y trouver 1900 codes sources dans tous les domaines (internet, windows, base de données, etc
Et pour finir quelques logiciels développés avec PureBasic :
k-billing : Un logiciel de facturation
GeoControl : Un générateur de terrain innovant
Soccer-Trainer : Un logiciel d'entraînement de football
XIII. Remerciements
Je tiens à remercier tout particulièrement
Alcatîz pour son aide,
Dut pour la relecture de l'article ainsi que les membres de la communauté PureBasic pour leur participation à la rédaction de cet article, sans oublier l'équipe PureBasic qui travaille sans relâche pour améliorer ce fabuleux langage.


Ce document est issu de http://www.developpez.com et reste la propriété exclusive de son auteur.
La copie, modification et/ou distribution par quelque moyen que ce soit est soumise à l'obtention préalable de l'autorisation de l'auteur.