FAQ PureBasicConsultez toutes les FAQ

Nombre d'auteurs : 7, nombre de questions : 68, dernière mise à jour : 3 janvier 2013  Ajouter une question

 

Bienvenue dans la F.A.Q. PureBasic !

Celle-ci va tenter de répondre aux questions les plus fréquemment posées sur le langage PureBasic et tous ses outils de programmation. Si elle n'a pas pour vocation de répondre à toutes les interrogations possibles, elle reste une bonne base de connaissances sur le PureBasic, et ne demande qu'à être enrichie par vos expériences personnelles.

Bien entendu, malgré toute l'attention qui a pu être portée à cette F.A.Q., des erreurs ont toujours pu s'y glisser. Prenez donc toutes les précautions qui s'imposent avant d'essayer un exemple.

Nous vous souhaitons une bonne lecture ! Et n'oubliez pas qu'en cas de problème, vous pourrez toujours poser votre question sur le forum PureBasic !

L'équipe PureBasic de Developpez.


SommaireCompilateur (7)
précédent sommaire suivant
 

Le compilateur est très docile, si on lui demande gentiment il est capable de répondre à nos questions. On peut par exemple lui demander la liste des champs dans une structure donnée, ou lui demander la liste des fonctions qu'il connait, on obtient ainsi non seulement la liste des fonctions PureBasic mais aussi la liste des fonctions des bibliothèques tierces installées dans le répertoire PureBasic. Mais avant d'interroger le compilateur il faut le démarrer. Pour cela on utilise tout simplement la commande RunProgram() avec les options suivantes :

  • #PB_Program_Hide : Lance le programme en mode invisible.
  • #PB_Program_Open : Ouvre des canaux de communication entre le programme lancé et le programme PureBasic.
  • #PB_Program_Read : Lecture possible sur la sortie standard (stdout).
  • #PB_Program_Write : Ecriture possible sur l'entrée standard (stdin).

Code purebasic : Sélectionner tout
1
2
3
4
5
6
7
8
9
 
Compilateur = RunProgram(#PB_Compiler_Home+"Compilers\Pbcompiler.exe", "/STANDBY", "", #PB_Program_Open|#PB_Program_Read|#PB_Program_Write|#PB_Program_Hide) 
If Compilateur = 0 
  MessageRequester("Pas de bol", "Le compilateur ne démarre pas") 
  End 
EndIf 
; Version du compilateur 
; 
Reponse$ = ReadProgramString(Compilateur)
/STANDBY (Windows) ou --standby (Linux/Mac) : Le compilateur attend une commande sur l'entrée standard (stdin) et répond sur la sortie standard (stdout)

Mis à jour le 14 février 2008 comtois

Une fois que vous avez démarré le compilateur, vous devez vérifier qu'il est prêt à discuter avec vous.

Code purebasic : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
 
; Vérifie que le compilateur soit prêt 
; 
Reponse$ = ReadProgramString(Compilateur) 
 
If StringField(Reponse$, 1, Chr(9)) = "ERROR" 
  MessageRequester("", "Erreur: " + StringField(Reponse$, 2, Chr(9))) 
  CloseProgram(Compiler) 
  End 
EndIf

Mis à jour le 14 février 2008 comtois

Ok, le compilateur est démarré, il est prêt, alors posons lui une question. Certaines questions ont un paramètre, d'autres non.

Exemple de requête sans paramètre, en réponse Le compilateur renvoie la liste de toutes les structures :

Code purebasic : Sélectionner tout
1
2
3
4
5
6
 
; interroge le compilateur 
; 
Demande$="STRUCTURELIST" 
Parametre$="" 
WriteProgramStringN(Compilateur, Demande$+Chr(9)+Parametre$)
Autre exemple de requête avec un paramètre, le compilateur renvoie la liste des champs de la structure indiquée en paramètre :

Code purebasic : Sélectionner tout
1
2
3
4
5
6
 
; interroge le compilateur 
; 
Demande$="STRUCTURE" 
Parametre$="point" 
WriteProgramStringN(Compilateur, Demande$+Chr(9)+Parametre$)
Pour connaître la liste des requêtes possibles consultez le fichier CompilerInterface.txt qui se trouve dans le répertoire sdk de PureBasic.

Mis à jour le 14 février 2008 comtois

Il suffit de créer une boucle qui récupère les réponses jusqu'à l'information 'OUTPUT [TAB] COMPLETE'

Code purebasic : Sélectionner tout
1
2
3
4
5
6
7
8
9
 
; Récupère la réponse du compilateur 
Repeat 
  Reponse$ = ReadProgramString(Compilateur) 
  If Reponse$ = "OUTPUT"+Chr(9)+"COMPLETE" 
    Break 
  EndIf 
  Texte$ + Reponse$ + Chr(13) 
ForEver
Ensuite il faut terminer l'échange en envoyant la requête 'END'

Code purebasic : Sélectionner tout
1
2
3
4
 
;Termine l'échange avec le compilateur 
WriteProgramStringN(Compilateur, "END") 
CloseProgram(Compilateur)
Et on peut enfin afficher le résultat

Code purebasic : Sélectionner tout
1
2
3
 
;Affiche le résultat 
MessageRequester("", Texte$)

Mis à jour le 14 février 2008 comtois

Vous souhaitez adapter la syntaxe de PureBasic à votre besoin ?
Par exemple, pour accéder au champ d'une structure vous devez l'écrire ainsi : MaVariable\Champ1, et vous aimeriez l'écrire de cette façonMaVariable->Champ1.
Seulement le compilateur ne comprend pas cette syntaxe, et c'est là que le préprocesseur intervient, il transformera votre MaVariable->Champ1 en MaVariable\Champ1 avant de lancer la compilation.

Quelques utilisateurs de PureBasic ont écrit un préprocesseur pour coder dans le style POO (voir ce site pour en savoir plus), ici on se contentera de présenter un exemple très simple.

Dans notre exemple, il s'agit de remplacer tous les "Hello" par des "Yellow".

Commencez par créer un exécutable à partir de ce code:

Code purebasic : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
; 
; Simple preprocessor example that replaces all "Hello" with "Yellow" 
; 
#FILE_Input  = 0 
#FILE_Output = 1 
  
; Read the temporary filename used by the compiler (first argument) 
File$ = ProgramParameter() 
  
; Get a path for our temporary file 
Temp$ = GetTemporaryDirectory() + "ToolTest.pb" 
  
; Make a copy of the compiler used file, so it can be overwritten 
If CopyFile(File$, Temp$) 
  ; read the copy 
  If ReadFile(#FILE_Input, Temp$) 
    ; re-create the compiler used file so it can be filled with the modified version 
    If CreateFile(#FILE_Output, File$) 
      While Not Eof(#FILE_Input) 
        ; process the lines 
        Line$ = ReadString(#FILE_Input) 
        Line$ = ReplaceString(Line$, "Hello", "Yellow") 
        WriteStringN(#FILE_Output, Line$) 
      Wend 
    
      CloseFile(#FILE_Output) 
    EndIf 
  
    CloseFile(#FILE_Input) 
  EndIf 
  
  ; Delete the copy 
  DeleteFile(Temp$) 
EndIf
Ensuite configurez un nouvel outil avec les paramètres suivants:

  • Ligne de commande : indiquez l'emplacement de l'exécutable créé avec le code ci-dessus
  • Arguments : "%COMPILEFILE" (en ajoutant les " pour prendre en compte les chemins comportants des espaces)
  • Evénement pour déclencher l'outil : Avant Compiler/Exécuter
  • Attendre la fin du programme : Coché

Ce qui permettra d'exécuter votre outil quand vous lancerez 'Compiler/Exécuter' à partir du menu de l'EDI.
Vous pouvez aussi ajouter un autre outil avec l'événement 'Avant de créer un exécutable' pour lancer l'outil dans cette situation.

Maintenant compilez un code comme celui ci et observez ce qui se passe :

Code purebasic : Sélectionner tout
1
2
 
MessageRequester("", "Hello World!")

Mis à jour le 14 novembre 2009

Nécessite : Bash, Wine 1.2+, any 64-bit Linux
Utilisation :
./ScriptName SourceFileName ExecutableFileName

Une seule ligne de commande pour créer les exécutables Win32, Win64, Linux 32 and Linux 64.

Code purebasic : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
#!/bin/bash 
# Script for PureBasic crosplatform build 
 
# Path to PB compilers 
# !!! CHANGE THIS PATH TO YOU PUREBASIC PATHES !!! 
PureBasic_Path_Linux_x86="/home/jule/Soft/PureBasic/Linux86" 
PureBasic_Path_Linux_x64="/home/jule/Soft/PureBasic/Linux64" 
PureBasic_Path_Windows_x86="/home/jule/.wine/drive_c/Program Files (x86)/PureBasic" 
PureBasic_Path_Windows_x64="/home/jule/.wine/drive_c/Program Files/PureBasic/Win64" 
 
# Check arguments 
if [ -n "$1" ]; then 
{ 
   src=$1 
} 
else 
{ 
   echo "Input source file name: " 
   read src 
} 
fi 
 
if [ -n "$2" ]; then 
{ 
   executableName=$src 
} 
else 
{ 
   echo "Input executable file name: " 
   read executableName 
} 
fi 
 
# Windows x86 
echo 
echo "Build Windows x86 binary" 
wine "$PureBasic_Path_Windows_x86"/Compilers/pbcompiler.exe $src /exe $executableName.Win32.exe /QUIET 
 
# Windows x64 
echo 
echo "Build Windows x64 binary" 
wine64 "$PureBasic_Path_Windows_x64"/Compilers/pbcompiler.exe $src /exe $executableName.Win64.exe /QUIET 
 
# Linux x86 
echo 
echo "Build Linux x86 binary" 
export PUREBASIC_HOME=$PureBasic_Path_Linux_x86 
export PATH=$PUREBASIC_HOME/compilers:$PATH 
$PureBasic_Path_Linux_x86/compilers/pbcompiler $src -e $executableName.Lin86 -q 
 
# Linux x64 
echo 
echo "Build Linux x64 binary" 
export PUREBASIC_HOME=$PureBasic_Path_Linux_x64 
export PATH=$PUREBASIC_HOME/compilers:$PATH 
$PureBasic_Path_Linux_x64/compilers/pbcompiler $src -e $executableName.Lin64 -q 
 
 
# Finish 
echo 
echo "******************************************" 
echo "Done!"

Mis à jour le 10 février 2011

Vous utilisez souvent les mêmes structures, constantes ou macros ? Tout ceci contenus dans un tas de fichiers que vous devez inclure selon vos différents projets, alors sachez qu'il y a plus simple --> Les fichiers résidents !

Ce sont des fichiers qui contiennent des structures (sans Array, List ou Map), des constantes et/ou des macros. Plus besoin d'include, ils sont disponibles au démarrage du compilateur.

Comment procéder ? Il suffit de copier les structures, les constantes et les macros que vous souhaitez rendre résidents dans un fichier source. Exemple :

Code purebasic : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
Enumeration 10 
  #Constante1   
  #Constante2 
EndEnumeration 
 
Structure s_Toto 
  Pos.f 
  Test.l 
EndStructure 
 
Structure s_titi 
  Champ.s_toto   
EndStructure 
 
Macro BorneMaxi(a, b) 
  If a > (b) 
    a = (b) 
  EndIf   
EndMacro
Enregistrez ce code dans un fichier que vous nommerez toto.pb. Puis copiez le code suivant dans le même répertoire que votre fichier toto.pb, et exécutez le.
Il va générer un fichier résident qui se nomme toto.res. Vous n'avez plus qu'à le copier dans votre répertoire PureBasic/Residents. Ou alors indiquez le chemin complet dans le code.

Code purebasic : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
Compilateur = RunProgram(#PB_Compiler_Home+"/Compilers/pbcompiler", "toto.pb /resident toto.res", "", #PB_Program_Open|#PB_Program_Read) 
  Sortie$ = "" 
  If Compilateur  
    While ProgramRunning(Compilateur) 
      If AvailableProgramOutput(Compilateur) 
        Sortie$ + ReadProgramString(Compilateur) + Chr(13) 
      EndIf 
    Wend 
    Sortie$ + Chr(13) + Chr(13) 
    Sortie$ + "Code de retour : " + Str(ProgramExitCode(Compilateur)) 
     
    CloseProgram(Compilateur) ; Ferme la connexion vers le programme 
  EndIf 
   
  MessageRequester("Sortie", Sortie$)
Avant de tester, fermez l'éditeur, et relancez le pour qu'il prenne en compte ce nouveau fichier au démarrage. Exemple de tests :

Code purebasic : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
 
Debug #Constante2 
 
a = 12 
BorneMaxi(a, 7) 
Debug a 
 
Define Truc.s_titi 
 
Truc\Champ\Test = 45
Vous pouvez obtenir le même résultat en lançant le compilateur depuis une invite de commande : pbcompiler "FileSource" /RESIDENT "FileResident".
On retrouve cette syntaxe dans le programme ci-dessus : RunProgram(#PB_Compiler_Home+"/Compilers/pbcompiler", "toto.pb /resident toto.res", "", #PB_Program_Open|#PB_Program_Read).

Mis à jour le 7 mars 2011 comtois

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2018 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
Responsable bénévole de la rubrique PureBasic : comtois -