Présentation de PureBasic

Par Comtois

Date de publication : 11 février 2008

Dernière mise à jour : 29 novembre 2012

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.
Commentez
 Présentation de PureBasic par Comtois

I - Avant-propos........................................................................................................................................................... 3
II - Introduction.............................................................................................................................................................3
III - IDE.........................................................................................................................................................................3
III-1 - Gestion des projets...................................................................................................................................... 3
III-2 - Aide syntaxique............................................................................................................................................ 4
III-3 - Pliage............................................................................................................................................................ 4
III-4 - Auto complétion............................................................................................................................................4
III-5 - Coloration......................................................................................................................................................4
III-6 - Outils intégrés...............................................................................................................................................4
III-7 - Outils personnalisés..................................................................................................................................... 5
III-8 - Préférences...................................................................................................................................................6
IV - Compilateur...........................................................................................................................................................7
V - Débogueur............................................................................................................................................................. 7
V-1 - Purificateur.................................................................................................................................................... 7
VI - Profileur.................................................................................................................................................................7
VII - Le langage........................................................................................................................................................... 8
VII-1 - Variables......................................................................................................................................................9
VII-2 - Structure...................................................................................................................................................... 9
VII-3 - Pointeur..................................................................................................................................................... 10
VII-4 - Pseudotype................................................................................................................................................11
VII-5 - Prototype................................................................................................................................................... 11
VII-6 - Interface.....................................................................................................................................................12
VII-7 - Procédure.................................................................................................................................................. 12
VII-8 - Liste chaînée.............................................................................................................................................13
VII-9 - Map (Table de hachage)...........................................................................................................................13
VII-10 - Base de données.................................................................................................................................... 14
VII-11 - Macro.......................................................................................................................................................15
VII-12 - Import...................................................................................................................................................... 15
VII-13 - DLL.......................................................................................................................................................... 16
VIII - API.................................................................................................................................................................... 16
VIII-A - Windows...................................................................................................................................................16
VIII-B - Linux.........................................................................................................................................................17
VIII-C - Mac OS....................................................................................................................................................18
IX - Bibliothèques.......................................................................................................................................................18
X - Assembleur.......................................................................................................................................................... 19
XI - Documentations.................................................................................................................................................. 19
XII - Liens...................................................................................................................................................................19
XIII - Remerciements................................................................................................................................................. 20

-2-
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.
http://comtois.developpez.com/tutoriels/purebasic/presentation/
 Présentation de PureBasic par Comtois

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.
Le langage est continuellement en développement, pour vous donner une petite idée de l'évolution, voici un graphique
intéressant :

Nombre de fonctions par version

La version 2.0 est sortie en octobre 2000 et la version 4.30 en décembre 2008.

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 - Gestion des projets

La gestion de Projets offre les possibilités suivantes :

• L'autocomplétion pour tous les fichiers du projet (même si ils ne sont pas ouverts).
• Dans les options du compilateur, vous pouvez ajouter autant de scénarios de compilation que vous le
souhaitez. Par exemple un scénario avec unicode, un scénario sans unicode, un scénario avec OpenGL un
autre avec DirextX9.
• Vous pourrez ensuite compiler votre projet selon les différents scénarios d'un simple clic.
• L'affichage d'une liste par projet des derniers fichiers ouverts.
• L'outil "Projet" permet un accès rapide aux fichiers du projet.

Pour une prochaine version, il est prévu d'ajouter :

-3-
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.
http://comtois.developpez.com/tutoriels/purebasic/presentation/
 Présentation de PureBasic par Comtois

• Backup: Spécification d'un répertoire pour sauvegarder tous les fichiers d'un projet.
• ToDo List: Gestion d'une 'todo list' par projet.

III-2 - 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-3 - 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-4 - 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.

Auto complétion

III-5 - 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-6 - 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.

-4-
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.
http://comtois.developpez.com/tutoriels/purebasic/presentation/
 Présentation de PureBasic par Comtois

III-7 - 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 :

; Adaptation en français par Flype d'un code créé par 'ts-soft' auteur de PBOSL.
;
; Objet :
;
; Aide en ligne MSDN pour l'éditeur intégré de PureBasic.
; Fonctionne comme l'aide Purebasic (Touche F1), mais pour les fonctions Win32.
; Reconnait les fonctions Win32 comme Beep_() et les constantes comme #MB_ICONERROR

; Installation :
;
; 1.
; Compiler ce source
;
; 2.
; Menu > Outils > Outils personnalisés > Nouveau
; Ligne de commande : L'exécutable compilé depuis ce source
; Nom : Aide en ligne MSDN (Par exemple)
; Evênement : Menu ou Raccourci
; Raccourci : Ctrl + F1 (Par exemple)

;
; Ici, il faut définir l'url qui va servir à la recherche
;

; Url.s = "http://www.google.com/search?q=site:msdn.microsoft.com+msdn+win32+%mot%&btnI=true"

Url.s = "http://search.msdn.microsoft.com/search/results.aspx?view=msdn&st=b&na=82&qu=%mot
%&s=1&swc=4"

;
; Ici, on récupère le mot qui est sous le curseur, dans l'éditeur intégré de Purebasic
;

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.

-5-
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.
http://comtois.developpez.com/tutoriels/purebasic/presentation/
 Présentation de PureBasic par Comtois

III-8 - 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.

-6-
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.
http://comtois.developpez.com/tutoriels/purebasic/presentation/
 Présentation de PureBasic par Comtois

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é.
Compilateur

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.

V-1 - Purificateur

Le purificateur permet de détecter plus facilement les dépassements de mémoire (buffer overflow).
Purificateur

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.

-7-
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.
http://comtois.developpez.com/tutoriels/purebasic/presentation/
 Présentation de PureBasic par Comtois

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
• NewMap
• Structure : EndStructure
• With : EndWith

Passons maintenant à ce qui peut distinguer PureBasic d'un autre BASIC.

-8-
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.
http://comtois.developpez.com/tutoriels/purebasic/presentation/
 Présentation de PureBasic par Comtois

VII-1 - Variables

Nom Extension Encombrement Plage

mémoire
Byte .b 1 octet -128 à +127
Byte .a 1 octet 0 à +255
Caractère .c 1 octet (ascii) 0 à +255
Caractère .c 2 octet (unicode) 0 à +65535
Word .w 2 octets -32768 à +32767
Word .u 2 octets 0 à +65535
Long .l 4 octets -2147483648 à
+2147483647
Integer .i 4 octets (32 bits) -2147483648 à
+2147483647
Integer .i 8 octets (64 bits) -9223372036854775808
à
+9223372036854775807
Float .f 4 octets illimité
Quad .q 8 octets -9223372036854775808
à
+9223372036854775807
Double .d 8 octets illimité
String .s Longueur de la illimité
chaîne + 1
String fixe .s{longueur} Longueur de la illimité
chaîne

Les nombres flottants (Simples ou doubles) peuvent être écrits sous la forme: 123.5e-20

Jusqu'à la version 4.20 le type par défaut était le type long (.l). A partir de la version 4.30, le
type par défaut est le type integer (.i).
En effet il existe désormais une version 32 bits, et une version 64 bits. Le type integer sera
donc de 4 ou 8 octets selon le système.

Les variables

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)

; Ici la position '0' du tableau MesAmis()

; contiendra une personne et ses informations personnelles
MesAmis(0)\Nom = "Durand"

-9-
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.
http://comtois.developpez.com/tutoriels/purebasic/presentation/
 Présentation de PureBasic par Comtois

MesAmis(0)\Prenom = "Michel"
MesAmis(0)\Age = 32

A partir de la version 4.50 les objets dynamiques tel que les tableaux, listes et maps sont supportés dans les structures
et sont automatiquement initialisés quand l'objet utilisant la structure est déclaré.
Pour définir un tel champ, utilisez les mot-clés suivants: Array, List et Map. Vous pouvez combiner les listes, map
et tableaux, par exemple insérer une map dans une liste elle même insérée dans une liste.

Enumeration
#Ouvert
#Ferme
EndEnumeration

Structure S_Game
List MaListe.point()
Etat.i
EndStructure

Dim Jeu.S_Game(20, 20)

;Ajoute une liste chaînée à la case 2,3 du tableau

InitializeStructure(@Jeu(2,3), S_Game)

;Renseigne la case 2,3 du tableau

With Jeu(2,3)
\Etat = #Ouvert

;Ajoute deux éléments à la liste chainée

AddElement(\MaListe())
\MaListe()\x = 34
\MaListe()\y = 43
AddElement(\MaListe())
\MaListe()\x = 12
\MaListe()\y = 48
EndWith

;Affiche la liste chainée de la case 2,3 du tableau

ForEach Jeu(2,3)\MaListe()
Debug Jeu(2,3)\MaListe()\x
Debug Jeu(2,3)\MaListe()\y
Debug "*********"
Next

A partir de la version 5.00 les tableaux dynamiques insérés dans une structure peuvent être
multidimensionnels.

les structures

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) ; tableau de points

*Pointeur.Point = @Tableau() ; Récupère l'adresse du tableau

*Pointeur\x = 10 ; Modifie l'élément 0 du tableau
*Pointeur\y = 15

*Pointeur + SizeOf(Point) ; Pointe sur l'élément suivant

- 10 -
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.
http://comtois.developpez.com/tutoriels/purebasic/presentation/
 Présentation de PureBasic par Comtois

*Pointeur\x = 7 ; Modifie l'élément 1 du tableau

*Pointeur\y = 9

;Affiche le résultat
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.

Les pointeurs et l'allocation mémoire

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' est une variable de type 'ProtoMessageBox'
;
MsgBox.ProtoMessageBox = GetFunction(0, "MessageBoxA")
MsgBox(0, "Hello", "World") ; Les options peuvent être omises
EndIf

- 11 -
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.
http://comtois.developpez.com/tutoriels/purebasic/presentation/
 Présentation de PureBasic par Comtois

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:

; Nous allons considérer que vous voulez accéder à une fonction

; d'un objet externe en PureBasic. Premièrement, déclarez son interface.
;
Interface MyObject
Move(x,y)
MoveF(x.f,y.f)
Destroy()
EndInterface

; CreateObject est la fonction qui permet la création de l'objet.

; Création du premier objet..
;
Object1.MyObject = MyCreateObject()

; Et du deuxieme.
;
Object2.MyObject = MyCreateObject()

; Nous pouvons alors utiliser les fonctions de l'objet directement comme suit:
;
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

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) ; ou
a(10, 12, 15)

- 12 -
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.
http://comtois.developpez.com/tutoriels/purebasic/presentation/
 Présentation de PureBasic par Comtois

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() ; Déclaration de la liste MesAmis()

;Ajoute un élément à la liste MesAmis()

AddElement(MesAmis())
MesAmis()\Nom = "Durand"
MesAmis()\Prenom = "Michel"
MesAmis()\Age = 32
;Ajoute un autre élément à la liste MesAmis()
AddElement(MesAmis())
MesAmis()\Nom = "Dupont"
MesAmis()\Prenom = "François"
MesAmis()\Age = 29
;Affiche la liste
ForEach MesAmis()
Debug MesAmis()\Nom
Debug MesAmis()\Prenom
Debug MesAmis()\Age
Debug "-------------"
Next

Les listes chaînées

VII-9 - Map (Table de hachage)

Les maps (aussi connues sous la dénomination 'table de hachage' ou 'dictionnaire') sont des structures pour stocker
des données qui sont allouées dynamiquement en fonction du besoin. C'est une collection d'éléments qui sont
complètement indépendants les uns des autres.
Il est possible d'ajouter autant d'éléments que désiré (limité uniquement par la quantité de mémoire disponible), et
de les consulter à l'aide d'une clef. Ce type de gestion de données est très utile quand un accès rapide à un élément
quelconque est requis. L'ordre d'insertion des éléments n'est pas conservé (contrairement à une liste chaînée), une
map ne peut donc pas être triée.
Exemple d'utilisation : La coloration syntaxique de l'IDE a en mémoire tous les noms de commandes pour savoir si
un mot est une fonction ou pas. Il suffit de créer une map avec tous les noms de commandes (qui sont forcément
uniques) ainsi on sait très rapidement si un mot est une commande ou pas. C'est beaucoup plus rapide que de
parcourir une liste contenant ces mots (même triée) car l'implémentation est faite pour ce genre d'utilisation.
Exemple :

Structure s_Abonne
Nom.s
Prenom.s
EndStructure

NewMap AnnuaireInverse.s_Abonne()

;On ajoute deux abonnés

AnnuaireInverse("03811234")\Nom = "Dupont"
AnnuaireInverse()\Prenom = "philippe"

- 13 -
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.
http://comtois.developpez.com/tutoriels/purebasic/presentation/
 Présentation de PureBasic par Comtois

AnnuaireInverse("03819876")\Nom = "Durand"
AnnuaireInverse()\Prenom = "mireille"

;Affiche la liste des abonnés

ForEach AnnuaireInverse()
Debug " --> " + AnnuaireInverse()\Nom + " - " + AnnuaireInverse()\Prenom
Next

;Cherche l'abonné correspondant à un numéro

Debug "Cherche l'abonné ...."
Numero.s = "03819876"
If FindMapElement(AnnuaireInverse(), Numero)
Debug " --> " + AnnuaireInverse()\Nom + " - " + AnnuaireInverse()\Prenom
Else
Debug "Numéro de téléphone inconnu"
EndIf

Les maps

VII-10 - Base de données

Avec la bibliothèque database vous aurez accès aux bases de données SQLite ou à tous types de bases de
données (Oracle, MySQL, Access, etc..) via l'API commune ODBC. La bibliothèque est basée sur des requêtes SQL
pour lire / écrire des données dans une base.
l'accès à PostgreSQL voit le jour avec la version 4.40 de PureBasic.
Exemple :

Procedure CheckDatabaseUpdate(Database, Query$)

Result = DatabaseUpdate(Database, Query$)
If Result = 0
Debug DatabaseError()
EndIf

ProcedureReturn Result
EndProcedure

UsePostgreSQLDatabase()

; You should have a server running on localhost

;
If OpenDatabase(0, "host=localhost port=5432", "postgres", "postgres")

CheckDatabaseUpdate(0, "CREATE TABLE food (name CHAR(50), weight INT)")

CheckDatabaseUpdate(0, "INSERT INTO food (name, weight) VALUES ('apple', '10')")
CheckDatabaseUpdate(0, "INSERT INTO food (name, weight) VALUES ('pear', '5')")
CheckDatabaseUpdate(0, "INSERT INTO food (name, weight) VALUES ('banana', '20')")

If DatabaseQuery(0, "SELECT * FROM food WHERE weight > 7")

While NextDatabaseRow(0)
Debug GetDatabaseString(0, 0)
Wend

FinishDatabaseQuery(0)
EndIf

Else
Debug "Can't open database !"
EndIf

Vous trouverez un tutoriel sur l'utilisation de SQLite à cette adresse.

- 14 -
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.
http://comtois.developpez.com/tutoriels/purebasic/presentation/
 Présentation de PureBasic par Comtois

Base de données

VII-11 - 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) ; renvoie le texte dans la casse du type spécifié

Type#Case(Texte) ; Type U => MAJUSCULES
EndMacro ; Type L => minuscules
Debug XCase(U, "Salut") ; macro remplacée par UCase("Salut")
Debug XCase(L, "Salut") ; macro remplacée par LCase("Salut")

VII-12 - 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"
; Pas besoin d'utiliser 'As' car PureBasic préfixe la fonction correctement
; Nous définissons également le paramètre 'Options' comme facultatif, avec une valeur par défaut de 0 (quand il
;
MessageBoxA(Fenetre.l, Corps$, Titre$, Options.l = 0)

; Cette fois PureBasic ne peut pas se débrouiller tout seul, car le

; nom de la fonction n'est pas le même que celui utilisé par le symbole
;
BoiteDeMessage(Fenetre.l, Corps$, Titre$, Options.l) As "_MessageBoxA@16"

EndImport

MessageBoxA(0, "Salut", "le Monde") ; Nous ne précisons pas les options

BoiteDeMessage(0, "Salut", "le Monde 2", 0)

Autre exemple :

ImportC "MSVCRT.LIB"
; int sprintf( char *buffer, const char *format, ... )
; Output is sent to buffer. Return value is number of characters written.
; Since variable arguments, must declare a specific function for each combination required.
CompilerIf #PB_Compiler_Processor = #PB_Processor_x86
sPrintf.l(result.s,format.s,num.d) As "_sprintf"
sPrintf_LLD.l(result.s,format.s,num1.l,num2.l,num.d) As "_sprintf"
CompilerElse
sPrintf.l(result.s,format.s,num.d) As "sprintf"
sPrintf_LLD.l(result.s,format.s,num1.l,num2.l,num.d) As "sprintf"
CompilerEndIf

EndImport ;/* Print a floating-point number in engineering notation */

; Format Specifier Type
; %d (Or %i) int
; %c char
; %f float
; %lf double
; %s string
; %x hexadecimal

- 15 -
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.
http://comtois.developpez.com/tutoriels/purebasic/presentation/
 Présentation de PureBasic par Comtois

Define.d x
Define.l rl
Define.s s,sf
x=-123.456e2
s=Space(32)

sf = "%+e"
sprintf(s,sf,x)
Debug "Using " + sf + " = " + s

sf="%10.2lf"
sprintf(s,sf,x)
Debug "Using " + sf + " = " + s

sf="%+*.*lf"
; use 3 for the width, 4 for the precision and 'x' as the value to format.
sprintf_lld(s, sf, 8, 3, x)
Debug "Using " + sf + " = " + s

End

VII-13 - DLL

PureBasic permet de créer :

• Des DLL Microsoft Windows (DLL : Dynamic Linked Library)

• Des objets partagés (.so) sous Linux
• Des bibliothèques dynamiques (.dylib) sous MacOS X

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.

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.

Ces fonctions ne sont disponibles qu'avec la version complète. Avec la version démo vous
pouvez utiliser l'API mais vous devrez importer les fonctions qui vous intéressent, et vous
devrez déclarer les constantes et structures nécessaires.

Vous trouverez plus d'informations sur les APIs utilisées dans les bibliothèques de PureBasic
à cette adresse.

VIII-A - Windows

Exemple de code utilisant l'API windows (Vérifiez que l'option 'Activer le support des thèmes XP' du compilateur n'est
pas validée pour tester ce code) :

- 16 -
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.
http://comtois.developpez.com/tutoriels/purebasic/presentation/
 Présentation de PureBasic par Comtois

;Sparkie 31/10/09
Procedure WindowCallback(hwnd, msg, wParam, lParam)
Select msg
Case #WM_CLOSE
DestroyWindow_(hwnd)
Case #WM_DESTROY
PostQuitMessage_(0)
result = 0
Default
result = DefWindowProc_(hwnd, msg, wParam, lParam)
EndSelect
ProcedureReturn result
EndProcedure

WindowClass.s = "SparkieClass"
wc.WNDCLASSEX
wc\cbSize = SizeOf(WNDCLASSEX)
wc\lpfnWndProc = @WindowCallback()
wc\hCursor = LoadCursor_(0, #IDC_ARROW)
wc\hbrBackground = #COLOR_WINDOW
wc\lpszClassName = @WindowClass
RegisterClassEx_(@wc)

hWndMain = CreateWindowEx_(0, WindowClass, "Testing", #WS_VISIBLE | #WS_BORDER | #WS_SYSMENU

, 10, 10, 300, 300, 0, 0, 0, 0)

;...Group of OptionGadgets
CreateWindowEx_(0, "Button", "Option1", #WS_CHILD | #WS_VISIBLE | #WS_GROUP | #WS_TABSTOP | #BS_AUTORADIOBUTTON, 3
hWndMain, 0, GetModuleHandle_(0), 0)
CreateWindowEx_(0, "Button", "Option2", #WS_CHILD | #WS_VISIBLE | #BS_AUTORADIOBUTTON, 30, 50, 100, 30,
hWndMain, 1, GetModuleHandle_(0), 0)
CreateWindowEx_(0, "Button", "Option3", #WS_CHILD | #WS_VISIBLE | #BS_AUTORADIOBUTTON, 30, 80, 100, 30,
hWndMain, 2, GetModuleHandle_(0), 0)

;...Group of ButtonGadgets
CreateWindowEx_(0, "Button", "Button 1", #WS_CHILD | #WS_VISIBLE | #WS_GROUP | #WS_TABSTOP | #BS_PUSHBUTTON | #BS_
hWndMain, 3, GetModuleHandle_(0), 0)
CreateWindowEx_(0, "Button", "Button 2", #WS_CHILD | #WS_VISIBLE | #BS_PUSHBUTTON | #BS_TEXT, 30, 150, 100, 30,
hWndMain, 4, GetModuleHandle_(0), 0)
CreateWindowEx_(0, "Button", "Button 3", #WS_CHILD | #WS_VISIBLE | #BS_PUSHBUTTON | #BS_TEXT, 30, 180, 100, 30,
hWndMain, 5, GetModuleHandle_(0), 0)

While (GetMessage_(@msg.MSG, #Null, 0, 0))

If Not IsDialogMessage_(hWndMain, @msg)
TranslateMessage_(@msg)
DispatchMessage_(@msg)
EndIf
Wend

VIII-B - Linux

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

- 17 -
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.
http://comtois.developpez.com/tutoriels/purebasic/presentation/
 Présentation de PureBasic par Comtois

Si une fonction manque , il est possible de l'importer facilement :

; ---------------------------------------------------------------------------------------
; using the GTK print dialog
; ---------------------------------------------------------------------------------------
;---------------- Preparations ---------------------------------------------------
;import needed functions
ImportC "/usr/lib/libgtk-x11-2.0.so"
gtk_print_operation_new()
gtk_print_operation_run(*op, action, *parent, *error);the print dialog
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); a (translated) string
gtk_print_operation_get_status (*op);the numer enumerated below
gtk_print_operation_is_finished (*op);returns true or false
EndImport

VIII-C - Mac OS

Le framework Cocoa voit le jour avec la version 5.00, le framework Carbon est toujours disponible en tant que sous
système (dans les options du compilateur).
Vous trouverez des exemples, des trucs et des astuces concernant le framework Cocoa à cette adresse.
Vous trouverez quelques exemples pour Carbon sous MacOS à cette adresse.

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
• Gadget3D
• Window3D
• Sound3D
• Node
• JPEG2000
• Map (table de hachage)

- 18 -
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.
http://comtois.developpez.com/tutoriels/purebasic/presentation/
 Présentation de PureBasic par Comtois

Consultez la documentation pour un aperçu plus complet des bibliothèques disponibles.

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); <- wraps a value into [0,2*Pi) fringe

!fldpi; <- now i have pi into st0
!fadd st0,st0; <- now i have 2*pi into st0
!fld dword[p.v_angle]; <- now i have angle in st0, 2*pi into st1
!fprem; <- now i have the remainder of angle/(2*pi) division (i.e. angle
%(2*pi)) in st0, 2*pi in st1
!fadd st1,st0;<- now i have angle%(2*pi) in st0, 2*pi+angle%(2*pi) into st1
!fldz;<- now i have 0 in st0, angle%(2*pi) in st1, 2*pi+angle%(2*pi) into st2
!fcomip st1; <- compare st0 and st1, and pop the stack, which means i have now angle
%(2*pi) in st0, 2*pi+remainder into st1
!fcmovnbe st0,st1; <- transfer st1 to st0 if not below or equal.
!fstp st1; <- store st0 in st1 and pops stack, which means i have now the result in st0
ProcedureReturn; <- return the result with this last pop
EndProcedure
Procedure.f WrapAngleDeg(angle.f); <- wraps a value into [0,360) fringe
!fild dword[@f] ; <- now i have 360 into st0
!fld dword[p.v_angle]
!fprem
!fadd st1,st0
!fldz
!fcomip st1
!fcmovnbe st0,st1
!fstp st1
ProcedureReturn
!@@:dd 360
EndProcedure

XI - Documentations

Vous pouvez consulter la documentation en ligne.

Ou télécharger la documentation au format pdf.

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.

- 19 -
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.
http://comtois.developpez.com/tutoriels/purebasic/presentation/
 Présentation de PureBasic par Comtois

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
Le blog officiel de PureBasic, il contient des informations très importantes, à lire absolument !
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.

- 20 -
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.
http://comtois.developpez.com/tutoriels/purebasic/presentation/