Compilation d'un programme

Le menu "Compilation"

Compiler/Exécuter
Lance la compilation du code source en cours d'édition en tenant compte de ses options de compilation. Le programme est créé dans un répertoire temporaire, mais il sera exécuté comme si il avait été lancé à partir du répertoire du code source (donc charger un fichier de ce répertoire fonctionnera).
Le code source n'a pas besoin d'être enregistré pour être compilé (mais les fichiers qu'il inclut doivent être enregistrés).

La commande "Compiler/Executer" utilise le paramétrage du débogueur (actif ou inactif), qu'il soit défini à partir du menu ou des options de compilations (les deux reviennent au même).

Exécuter
Exécute le dernier programme compilé une nouvelle fois. Tout changement concernant le débogueur (actif ou inactif) ne sera pas pris en compte par cette commande.

Compiler avec le débogueur
Lance la compilation de la même manière que la commande "Compiler/Exécuter", en forçant l'utilisation du débogueur. Cela permet de tester rapidement une compilation avec le débogueur lorsqu'il est normalement désactivé.

Compiler sans le débogueur
Lance la compilation de la même manière que la commande "Compiler avec le débogueur", en désactivant le débogueur.

Relancer le compilateur (Windows uniquement)
Relance le compilateur et réinitialise toutes les bibliothèques et résidents chargées (sous Windows, le compilateur se lance lors du démarrage de l'IDE et se met en attente pour une plus grande rapidité). Cela a pour effet de mettre à jour la liste des fonctions, structures, interfaces et constantes reconnues par l'IDE. Cette commande permet de charger une nouvelle bibliothèque utilisateur nouvellement installée sans redémarrer l'IDE. De plus, pour les développeurs de bibliothèques, cela facilite le test en évitant de relancer l'IDE.

Options de compilation
Ouvre la fenêtre d'options, qui permet d'ajuster les paramètres concernant la compilation du code source en cours d'édition. Cible par défaut
Quand un projet est ouvert, ce sous-menu permet de changer rapidement de cible par défaut. La cible par défaut est celle qui sera lancée automatiquement par le menu "Compiler/Exécuter.

Créer une cible
Quand un projet est ouvert, ce sous-menu montre toutes les cibles disponibles et permet d'en compiler directement une d'entre elles.

Créer toutes les cibles
Quand un projet est ouvert, ce menu compile toutes les cibles qui ont l'option idoine activée dans les options de compilation. Une fenêtre s'ouvre permettant de suivre l'état d'avancement des compilations.

La fenêtre d'options de compilation pour les fichiers hors projets

Fichier principal
En activant cette option, il est possible de définir un fichier principal pour la compilation du fichier actuel. Ce sera ce fichier qui sera alors utilisé lors de la compilation et non le fichier en cours d'édition.

Note: quand cette option est utilisée, le fichier en cours d'édition doit être enregistré avant de lancer la compilation, sinon les modifications ne seront pas prises en compte (car les fichiers inclus sont chargés à partir du disque). La plupart des options de compilation seront héritées du fichier principal, seuls les paramètres concernant le débogueur et la ligne de commande seront propres au fichier actuel.

Icone (Uniquement pour Windows et MacOS X)
Il est possible de spécifier une icône qui sera associée à l'exécutable et affichée dans l'Explorateur Windows (ainsi que dans le coin supérieur gauche des fenêtres du programme et dans la barre des tâches).

Activer le support de l'assembleur en ligne
Active l'assembleur en ligne, ce qui permet de mixer librement du code assembleur avec du code BASIC. Voir la section Assembleur en ligne x86 pour plus d'informations.

Créer un exécutable unicode
Informe le compilateur qu'il doit utiliser les routines unicode lors de la création de l'exécutable. Les fonctions de gestion des chaînes de caractères ainsi que toutes les fonctions PureBasic fonctionneront en unicode. Pour pouvoir exploiter les chaînes de caractères unicode directement à partir du code source, il est recommandé d'activer l'encodage UTF-8 (voir plus ci-dessous).

Pour déboguer un programme unicode, il faut sélectionner le débogeur autonome dans les préférences, car le débogueur qui est intégré à l'IDE ne peut pas, pour l'instant, afficher du texte unicode (le texte est converti en ascii avant affichage).

Créer un exécutable multi-threadé
Informe le compilateur qu'il doit utiliser les routines multi-threadées lors de la création de l'exécutable (voir la bibliothèque Thread pour plus d'information).

Ce mode permet aussi au débogueur d'afficher correctement les informations si des threads sont utilisés. Sans cette option, le débogueur peut afficher un numéro de ligne erroné si une erreur intervient à l'intérieur d'un thread.

Activer le support des skins XP (Uniquement pour Windows)
Ajoute un fichier permettant la gestion des skins, lorsque le programme est exécuté sur Windows XP ou Windows Vista (fortement recommandé).

Requiert le mode Administrateur pour Windows Vista (Windows seulement)
L'exécutable créé sera toujours lancé avec les droits d'administration (i.e vous devez être logué en tant qu'administrateur système) sous windows vista. (il ne s'exécutera pas si le mot de passe de l'administrateur n'est pas donné). Cette option sera définie pour des programmes qui ont besoin d'un accès à des dossiers ou à des zones de registres à accès restreint afin d'obtenir un accès complet.
Si cette option est activée, le débogueur indépendant sera automatiquement sélectionné pendant la phase de débogage, ainsi le programme pourra être testé sous le mode administrateur.

Note : cette option n'a aucun effet quand le programme est lancé sous d'autres versions de windows.

Requiert le mode utilisateur pour Windows Vista (Windows seulement)
Cette option désactive la «virtualisation» de cet exécutable sur Windows Vista. La Virtualisation provoque la redirection des fichiers et les accès au Registre vers un dossier utilisateur si l'utilisateur n'a pas les droits nécessaires à l'opération. (ce qui permet de conserver la compatibilité avec d'anciens programmes)
Notez que cette redirection se fait sans en aviser l'utilisateur ce qui peut conduire à une certaine confusion si il essaye de trouver les fichiers sauvegardés sur le système de fichiers. Pour cette raison, il est recommandé de désactiver cette fonctionnalité si le logiciel est conforme avec les règles d'accès aux fichiers ou du registre de Vista.

Note: cette option n'a aucun effet quand le programme est lancé sous d'autres versions de windows. Elle ne peut pas être combinée avec l'option "Mode Administrateur" ci-dessus.

Activer le support des lignes OnError (Uniquement pour Windows)
Ajoute des informations dans l'exécutable pour pouvoir identifier la ligne qui a provoqué une erreur (à utiliser en combinaison avec les commandes de la bibliothèque OnError). Cette option influe légèrement sur les performances du programme.

Sous-système
Il est possible ici de sélectionner le sous-système à utiliser lors de la compilation. Pour l'instant, les sous-systèmes suivant sont supportés: Windows
nt4 : utilise les bibliothèques DirectX3 pour être compatible avec Windows NT 4.
opengl : utilise l'OpenGL pour les bibliothèques sprite et sprite3D.

Linux
gtk1 : utilise Gtk1.2 à la place de Gtk2 pour les bibliothèques concernées (Window, Gadget etc.). Nécessite le package 'gtk1.2-dev'
Note : Ce sous système n'est plus maintenu, par conséquent quelques fonctionnalités peuvent être absentes.

MacOSX
Actuellement il n'y a pas de sous système officiel pour MacOSX.

Format des exécutables
Permet de déterminer le type de l'exécutable qui sera généré:
Windows : format par défaut sous Windows, convient pour tout type d'applications.
Console : un exécutable avec une console par défaut. Il est toujours possible de créer des fenêtre, boutons etc. avec ce type d'exécutable, mais une console sera toujours ouverte quand le programme est exécuté. Si le programme est exécuté à partir d'une ligne de commande, il utilisera ce terminal pour les sorties textes, là où un programme du type "Windows" nécessite la création d'une nouvelle console (à l'aide d'OpenConsole()). Si un programme peut avoir son entrée ou sa sortie redirigée (au travers de 'pipes'), cette option doit être utilisée.
DLL Partagé : crée une DLL Windows. Voir "Créer une DLL" pour plus d'informations.
Note: Quand un code source de type DLL est lancé avec "Compiler/Exécuter", il sera traité comme un programme classique, pour permettre de tester facilement les fonctions de la DLL. La DLL sera réellement créée en appellant la commande "Créer un exécutable".

Optimisations CPU (à coté de "Format de l'exécutable")
Cette option permet d'inclure des fonctions spécialement optimisées pour un type de processeur, lorsqu'elles sont disponibles.
Tout CPU : Les fonctions génériques qui fonctionnent sur tous les processeurs seront utilisées.
CPU Dynamique : Les fonctions génériques ainsi que les fonctions spécifiques à tous les CPU supportés seront intégrées à l'exécutable. Le choix des fonctions à utiliser se fera au démarrage de l'exécutable, en détectant dynamiquement le processeur sur lequel il est lancé. Cela crée des exécutables plus gros, mais que seront aussi rapides que possible.
Les autres options : Les fonctions spécifiques à un CPU seront utilisées (ainsi que les fonctions génériques pour celle qui n'ont pas de version spécifiques). L'exécutable ne fonctionnera que sur le processeur choisi.

Note: Pour le moment, aucune fonction de PureBasic n'intègre de version spécifique, mais quelques bibliothèques utilisateurs en propose.

Linker options file
A textfile can be specified here with further commandline options that should be passed to the linker when creating the executable. The file should contain one option per line.

Encodage des sources
Permet de choisir quel encodage sera utilisé lors de l'enregistrement du code source. L'encodage UTF-8 est fortement recommandé pour le développement d'un programme unicode, car les caractères unicodes peuvent être saisis directement dans l'IDE. De plus les fichiers UTF-8 peuvent aussi être utilisés pour compiler des programmes en mode ascii, ce qui permet de gérer les modes unicode et ascii de manière transparente.

Quand l'encodage UTF-8 est sélectionné, l'IDE ajoute automatiquement un BOM (Byte Order Mark) au début du fichier, pour que le compilateur PureBasic et les autres programmes puissent identifier correctement l'encodage du fichier.

Format des sources
Cette fonctionnalité n'affecte pas la compilation, mais permet de définir le format utilisé par le code source lorsqu'il sera enregistré sur le disque. Ce paramètre est déterminé automatiquement lors du chargement initial du fichier (ou utilise la valeur par défaut lors de la création de nouveaux sources). Si le format est modifié, alors le fichier utilisera ce format la prochaine fois qu'il sera enregistré sur le disque.

Pour pemettre la portabilité totale des sources sur les différentes plateformes que PureBasic supporte, l'IDE gère plusieurs type de format de fichiers textes. Par contre, les autres programmes n'en feront probablement pas de même donc il est conseillé, si possible, de garder le format natif de l'OS.

Compile/Run

This section contains options that affect how the executable is run from the IDE for testing. Except for the tools option, they have no effect when the "Create executable" menu is used.

Enable Debugger
This sets the debugger state (on/off) for this source code, or if the main file option is used, for that file too. This can also be set from the debugger menu.

Use selected Debugger
This allows to choose a different debugger type for this file only. If this option is disabled, the default debugger is used which can be specified in the preferences.

Executable Commandline
The string given here will be passed as the commandline to the program when running it from the IDE.

Current directory
The directory specified here will be set as the current directory for the program when running it from the IDE.

Create temporary executable in the source directory
With this option turned on, the temporary executable file for running the program from the IDE will be placed inside the source directory. This can be useful if the program depends on files inside the source directory for testing. With this option turned off, the executable is created in the systems temporary directory.

Execute tools
Here external tools can be enabled on a per-source basis. The "Global settings" column shows if the tool is enabled or disabled in the tools configuration. A tool will only be executed for the source if it is both enabled globally and for this source.

Note: For a tool to be listed here, it must have the "Enable Tool on a per-source basis" option checked in the tools configuration and be executed by a trigger that is associated with a source file. (ie not by menu or editor startup for example)

Constantes

Dans cette section, un ensemble de constantes spéciales pour l'éditeur aussi bien que des constantes personnalisées peuvent être définis pour ce qui sera prédéfini au moment de la compilation du code source.

#PB_Editor_CompileCount
Si cette constante est activée, elle contiendra le nombre de fois que le code a été compilé en choisissant aussi bien "Compiler/Exécuter" que "Créer un exécutable" dans le menu. Le compteur peut être édité manuellement dans le champ de saisie.

#PB_Editor_BuildCount
Si cette constante est activée, elle contiendra le nombre de fois que le code a été compilé en choisissant "Créer un exécutable" dans le menu. Le compteur peut être édité manuellement dans le champ de saisie.

#PB_Editor_CreateExecutable
Si cette constante est activée, elle aura la valeur 1 si le code est compilé en choisissant "Créer un exécutable" dans le menu ou 0 si "Compiler/Exécuter" est utilisé.

Constantes personnalisées
Here, custom constants can be defined and then easily switched on/off through checkboxes. Constant definitions should be added as they would be written within the sourcecode. This provides a way to enable/disable certain features in a program by defining a constant here and then checking in the source for it to enable/disable the features with CompilerIf/CompilerEndIf.

Inside the definition of these constants, environment variables can be used by specifying them in a "bash" like style with a "$" in front. The environment variable will be replaced in the constant definition before compiling the source. This allows to pass certain options of the system that the code is compiled on to the program in the form of constants.

Example: #Creator="$USERNAME"
Here, the $USERNAME will be replaced by the username of the logged in user on Windows systems. If an environment variable does not exist, it will be replaced by an empty string.

Note: To test within the sourcecode if a constant is defined or not, the Defined() compiler function can be used.

Informations de version

Si cette fonction est activée, une 'ressource' sera ajoutée à l'exécutable final contenant les informations de version du programme. Il est possible de les consulter en utilisant l'explorateur Windows et de sélectionner 'Propriétés' dans le menu contextuel. D'autres outils peuvent utiliser ces informations, comme par exemple les installateurs de programmes.

Les champs marqués avec une '*' sont indispensables, sinon les informations ne seront pas affichées correctement sur toutes les versions de Windows.
Les deux premiers champs doivent contenir 4 nombres séparés par des virgules. Tous les autres champs peuvent contenir n'importe quel texte. Dans les 3 boîtes vides, il est possible de définir ses propres champs à inclure dans les informations de version.

Dans tous les champs texte, il est possible d'intégrer des tags spéciaux qui seront remplacés par leur valeur associée lors de la compilation:
%OS : remplacé par la version de Windows utilisée pour compiler le programme.
%SOURCE : remplacé par le nom du fichier source (sans son chemin).
%EXECUTABLE : remplacé par le nom de l'exécutable créé (fonctionne uniquement quand "Créer un exécutable" est utilisé).
%COMPILECOUNT : remplacé par la valeur de la constante #PB_Editor_CompileCount.
%BUILDCOUNT : remplacé par la valeur de la constante #PB_Editor_BuildCount.

De plus, il possible d'utiliser n'importe quels tags supportés par la commande FormatDate(). Ils seront alors remplacés par leur valeur par rapport à la date de la compilation (ex: %yy correspondra à l'année de la compilation).

Définition des 3 champs du bas:

Fichier OS
Spécifie l'OS pour lequel ce programme est compilé (utiliser VOS_DOS ou VOS_WINDOWS16 n'a pas vraiment de sens pour un programme PureBasic, ils sont présents uniquement pour avoir une liste exhaustive).

Type du fichier
Défini le type de l'exécutable (ici seuls VFT_UNKNOWN, VFT_APP et VFT_DLL ont un sens pour les programmes PureBasic).

Langue
Spécifie la langue dans laquelle sont décrites ces informations de version.

Ressources

Permet d'inclure autant de scripts de ressources (fichiers *.rc) que nécessaire. Ils seront alors compilés et ajoutés à l'exécutable, et accessible dans le programme via les commandes API (étant donné que les ressources sont spécifiques à Windows, PureBasic ne les supporte pas de manière implicite, pour plus de renseignement consultez la MSDN). Pour créer facilement ces scripts, il est conseillé d'utiliser un éditeur de ressources tel que celui présent dans 'PellesC'.

La fenêtre d'options de compilation pour projets

La fenêtre "options de compilation pour projets" permet de définir plusieurs cibles de compilation. Chaque cible est un ensemble de paramètres de compilation avec un fichier source principal et un executable. La partie gauche de la fenêtre affiche la liste de toutes les cibles disponibles. La barre d'outils juste au dessus permet de créer, effacer, copier, éditer ou déplacer une cible.

La cible par défaut sera celle qui sera exécutée quand le menu "Compilateur/Exécuter" est sélectionné. Elle peut être rapidement changée par la case à cocher "Définir comme cible par défaut" ou à partir du menu "Compilateur". L'option "Autoriser dans 'Compiler toutes les cibles'" indique si cette cible doit être compilée quand le menu "Compiler toutes les cibles" est utilisé.

La partie droite de la fenêtre est quasiment la même qu'en mode hors projet, et reflète les paramètres de compilation de la cible actuellement selectionnée. Les seules différences sont les champs "Fichier source d'entrée" et "Executable de destination" qui doivent être renseignés pour chaque cible, car sans ces informations, il n'est pas possible de compiler la cible automatiquement.

En mode projet, les informations relatives à chaque cible sont enregistrées dans le fichier projet, et pas dans les fichiers sources. Les informations qui sont propres à chaque fichiers (comme l'état du pliage) sont toujours enregistrées pour chaque fichier à l'endroit indiqué dans les Preferences.

La fenêtre de compilation des cibles

Quand le menu "Créer toutes les cibles" est sélectionné pour le projet en cours, toutes les cibles qui ont l'option idoine activée seront compilées dans l'ordre où elles apparaissent dans la liste des cibles. La fenêtre de progression montre la cible et l'ensemble des cibles ainsi que leurs status. Quand le processus de compilation est fini, le log peut être copié dans le presse-papier ou enregistré sur le disque.