Problème à signaler:


Télécharger Support d’Initiation à la programmation en Basic



★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :

Support d’Initiation à la programmation en Basic




Support d’Initiation à la programmation en Basic

...

Chapitre 4 Installation

Pour installer PureBasic, cliquez sur l’icône d’installation et suivez les instructions. Cliquez ensuite sur l’icône PureBasic qui se trouve dans le menu démarrer ou sur le bureau.

Pour utiliser le compilateur en ligne de commande, il est conseillé de rajouter le répertoire ”compilers\” de l’installation PureBasic à la variable d’environnement ’PATH’. Ainsi la commande ’pbcompiler’ sera accessible à partir de n’importe quelle console.

Note : Pour éviter les conflits avec une ancienne version, installez toujours une nouvelle version de PureBasic dans un nouveau répertoire .

 Chapitre 5 Obtenir PureBasic

PureBasic est un langage de programmation très performant à un prix raisonnable. En achetant PureBasic, vous encouragez son développement et vous participez à son évolution future. Les mises à jour sont gratuites et illimitées, ce qui implique que vous ne paierez PureBasic qu’une seule et unique fois, contrairement à de nombreux autres logiciels. Encore plus fort, vous avez droit à toutes les versions de PureBasic pour toutes les plateformes actuellement supportées ,Windows, Linux et MacOS (AmigaOS pour les versions antérieures). Merci encore pour votre confiance et votre support!

La version de démonstration est limitée de la manière suivante :

- Impossible de créer une DLL

- Impossible d’utiliser les fonctions externe (API de l’OS)

- Pas de kit de développement pour ajouter des libraries à PureBasic

- Nombre maximum de lignes pour un programme: 800

Prix : La version complète de PureBasic :

Prix pour la version complète: 79 Euros

Prix spéciaux pour les licences entreprises (499 euros) et licences éducations (199 euros pour une classe).

Paiement en ligne sécurisé

La version complète sera envoyée par e-mail (email contenant un lien à télécharger) dès réception de la commande.

 Chapitre 6 Contacts

Veuillez envoyer vos suggestions, rapports de bugs, ou si vous voulez simplement nous contacter à une des adresses suivantes :

Frédéric ’AlphaSND’ Laboureur

Fred ’AlphaSND’ est le fondateur de Fantaisie Software et le programmeur principal de PureBasic. Toutes les suggestions, rapports de bugs etc... lui seront adressés à :

 Chapitre 8 Débuter avec l’IDE

L’IDE PureBasic est un environnement complet qui permet la création et l’édition de fichiers sources, leur compilation, débogage ainsi que la création de l’exécutable final. Il sert d’interface au compilateur ainsi qu’au débogueur .

La fenêtre principale de l’IDE se divise en 3 parties :

La zone d’édition du code (en dessous de la barre d’outils)

Tous les codes sources sont affichés ici. Il est possible de passer de l’un vers l’autre à l’aide des onglets situés entre la barre d’outils et la zone d’édition.

La palette d’outils (par défaut située à droite de la zone d’édition)

La palette contient plusieurs outils rendant la programmation plus facile et plus productive. Les outils affichés ici peuvent être configurés, déplacés ou même enlevés si besoin est. Voir Configurer l’IDE pour plus de renseignements.

Le rapport d’activité (situé en dessous de la zone d’édition)

Les erreurs de compilation ainsi que les messages d’erreur du débogueur seront affichés dans cette partie. Il peut être visible ou caché séparément pour chaque fichier.

Le reste de l’interface se compose du menu principal et de la barre d’outils. Cette dernière est simplement un raccourci des fonctions disponibles dans le menu et peut être complètement paramétrée (chaque fonction du menu peut être enlevée, déplacée ou ajoutée à la barre d’outils). Pour savoir ce que fait un bouton, il suffit de laisser le pointeur de la souris dessus un court instant et une aide apparaîtra (et affichera la fonction du menu correspondante). Les commandes du menu sont expliquées dans une autre section.

 Chapitre 9 Gestion des fichiers

Le menu ”Fichier” permet de réaliser les opérations de base tel que l’ouverture ou l’enregistrement des fichiers.

Il est possible d’éditer plusieurs codes sources simultanément, et de passer de l’un à l’autre grâce aux onglets situés sous la barre d’outils. Par défaut, les raccourcis claviers Ctrl+Tab et Ctrl+Shift+Tab permettent de passer au fichier suivant (ou précédent).

L’IDE permet l’édition de fichiers texte qui ne sont pas du code source. Dans ce mode ”texte brut”, les caractéristiques liées au code tels que la coloration synthaxique, la correction des cas, l’auto-completion automatique sont désactivées. Lors de l’enregistrement de ces fichiers, l’IDE n’ajoutera pas ses paramètres à la fin du fichier, même si cela est configuré pour les fichiers de code dans les préférences . Un fichier qui contient du code ou non dépend de son extension. Les extensions de fichiers standard PureBasic (pb, pbi et pbf) sont reconnues comme des fichiers contenant du code. Plusieurs extensions de fichier peuvent être reconnues comme des fichiers de code en les configurant dans la section ”Editeur” des Préférences .

Contenu du menu ”Fichier”

 Nouveau

Créé un nouveau code source vide.

Ouvrir

Ouvre un code source existant pour l’éditer.

Les fichiers de type ’texte’ seront tous chargés dans la zone d’édition. Il est aussi possible d’ouvrir des fichiers binaires et dans ce cas ils seront ouverts par le visualisateur de fichier interne.

 Enregistrer

Enregistre le source en cours d’édition sur le disque. S’il n’a pas encore été enregistré, son nom et son emplacement devront être définis à l’aide de la fenêtre de dialogue, sinon le code sera enregistré dans le fichier précédent.

Enregistrer sous

Enregistre le code source en cours d’édition à un emplacement différent. Une boîte de dialogue demandant le nom du nouveau fichier sera affichée. L’ancien code source restera inchangé.

Enregistrer tout

Enregistre tous les codes source ouverts.

Recharger

Recharge le fichier courant à partir du disque. Cela annulera tous les changements non sauvegardés. Fermer

Ferme le code source en cours d’édition. Si c’était le dernier fichier, l’IDE affichera un nouveau fichier vide.

Fermer tout

Ferme tous les codes source en cours d’édition. L’IDE affichera un nouveau fichier vide.

Voir changements

Affiche les modifications qui ont été apportées au code source courant par rapport à la version qui existe sur le disque dur.

Format du fichier

Dans ce sous-menu, il est possible de sélectionner le format d’encodage ainsi que les terminaisons de lignes du fichier courant. L’IDE supporte les fichiers textes ASCII ou UTF-8. Les terminaisons de ligne supportées sont : Windows (CRLF), Linux/Unix (LF) et MacOSX (CR). Les paramètres par défaut appliqués lors de la création d’un nouveau fichier peuvent être changés dans les préférences de l’IDE. Préférences

Cette fenêtre permet de contrôler le look et le comportement de l’IDE pour qu’il s’adapte aux besoins de chacun. Pour une description détaillée des fonctions disponibles, voir Configurer l’IDE .

Historique de session

L’historique de session est un outil puissant qui enregistre régulièrement les modifications apportées aux fichiers ouverts dans l’IDE, dans une base de données. Une session est créée lors du lancement de l’IDE, et est fermée lorsque l’IDE se ferme. Cette option est utile pour revenir à une version antérieure d’un fichier ou pour retrouver un fichier supprimé ou corrompu. C’est un peu comme un outil de sauvegarde des sources mais limité dans le temps (par défaut, un mois d’enregistrement). Il n’est pas destiné à remplacer un vrai système de gestion des sources comme SVN ou GIT. Le code source sera stocké sans chiffrement, donc si vous travaillez sur un code source sensible, assurez-vous d’avoir ce fichier de base de données dans un endroit sûr, ou désactiver cette fonction.

Pour configurer l’outil historique de la session, voir préférences .

Fichiers récents

Le sous-menu affiche la liste des dix derniers fichiers ouverts. Sélectionner un fichier dans le sous-menu l’ouvrira à nouveau.

Quitter

Cela permet bien entendu de quitter l’IDE. Si un ou plusieurs fichiers ne sont pas enregistrés, une confirmation pour chacun des fichiers sera demandée.

 Chapitre 10 Edition du code

L’IDE du PureBasic se comporte comme un éditeur de texte classique en ce qui concerne la saisie de texte. Les touches de curseur, Page précédente, Page suivante, Début et Fin permettent de se déplacer dans le code. Ctrl+Début se rend au début du code et Ctrl+Fin se déplace à la fin.

Les raccourcis par défaut Ctrl+C (copier), Ctrl+X (couper) et Ctrl+V (coller) servent à l’édition. La touche Insérer change le mode d’édition pour déterminer si le texte doit etre remplacé ou ajouté (le mode par défaut est l’ajout). La touche Supprimer supprime une lettre à droite du curseur. Maintenir la touche Shift appuyée et utiliser les flèches permet de sélectionner du texte.

Au delà des fonctions de base, l’IDE a de nombreuses fonctionnalités dédiées à la programmation PureBasic.

Indentation

Quand un retour à ligne est effectué, l’indentation (nombre d’espaces/tabulations en début de ligne) de la ligne courante et de la ligne suivante sera calculée automatiquement en fonction du mot-clé qui est présent sur la ligne. Un mode ”block” est aussi disponible. Dans ce cas, la nouvelle ligne aura la même indentation que la ligne courante. Tout ceci est paramètrable dans les preférences .

Caractères de tabulation

Par défaut, l’IDE n’insère pas une vraie tabulation quand la touche Tab est utilisée. En cas d’échange de source, ceci permet d’éviter les problèmes d’affichage inhérents aux normes de tabulation utilisées. A la place, deux caractères espaces sont insérés. Ce comportement peut être modifié dans les préférences de l’IDE (voir Configurer l’IDE ).

Comportement particulier de la touche Tab

Quand la touche Tab est utilisée alors que la sélection est vide ou ne contient que quelques caractères, elle agit comme décrit ci-dessus (insertion d’un nombre d’espaces, ou d’une vraie tabulation selon le réglage défini dans les préférences de l’IDE).

Quand la touche Tab est utilisée alors qu’une ou plusieurs lignes complètes sont sélectionnées, des espaces (ou des tabulations, en fonction de la configuration) sont insérés au début de chaque ligne. Cela permet d’indenter rapidement des blocs complets de code.

Quand la combinaison de touches Shift+Tab est utilisée alors que plusieurs lignes sont sélectionnées, les espaces/tabulations au début de chaque ligne sont supprimés afin de réduire l’indentation du bloc complet.

 Retrait (Indentation) / Alignement des commentaires :

Similaire au comportement de l’onglet spécial ci-dessus, les raccourcis clavier Ctrl+E et Ctrl+Maj+E (CMD+E et CMD+Maj+E sur OSX) peuvent être utilisés pour modifier le retrait des commentaires sélectionnés. Cela aide à aligner les commentaires à la fin du code, pour le rendre encore plus lisible. Les raccourcis utilisés peuvent être configurés dans les préférences .

Sélection des blocs de code :

Le raccourci Ctrl+M (CMD+M sur OSX) peut être utilisé pour sélectionner le bloc de code qui contient la position du curseur (par exemple un bloc ’If’, une boucle ou une procédure). Une utilisation répétée du raccourci sélectionne d’autres blocs de code environnant.

Le raccourci Ctrl+Maj+M (CMD+Maj+M sur OSX) a la fonction inverse et rétablit la sélection du bloc précédemment sélectionné avec Ctrl+M.

Les raccourcis utilisés peuvent être configurés dans les préférences .

Double-cliquer sur un mot

En principe, double-cliquer sur un mot le sélectionne. Néanmoins, dans quelques cas, le comportement est différent :

Maintenir la touche Ctrl appuyée et double-cliquer sur le nom d’une procédure , définie dans le même fichier, permet de se rendre directement à sa déclaration. Si la procédure se trouve dans un autre fichier, celui-ci doit déjà être ouvert dans l’IDE.



Double-cliquer sur un mot-clé IncludeFile ou XincludeFile ouvrira le fichier dans l’IDE (le nom du fichier doit être spécifié en entier, sans utiliser de constante par exemple).

De la même manière, double-cliquer sur le mot-clé IncludeBinary aura pour effet d’ouvrir le fichier dans le visualisateur de fichier intégré à l’IDE.

Marqueur de parenthèse et de mots-clés :

Quand le curseur est sur une parenthèse ouvrante ou fermante, l’IDE mettra en surbrillance l’autre parenthèse qui lui correspond. Si aucune parenthèse ne correspond (ce qui est une erreur de syntaxe en PureBasic), l’IDE affichera la parenthèse en rouge. Le même concept est appliqué aux mots-clés. Si le curseur est sur un mot-clé comme ”If”, l’IDE soulignera ce mot-clé et tous les autres mots-clés qui lui correspond, comme ”Else”, ”ElseIf” ou ”EndIf”. Si il manque des mots-clés, il sera souligné en rouge. Le menu ”Aller au mot-clé correspondant” décrit ci-dessous peut être utilisé pour aller rapidement d’un mot-clé à l’autre.

Le marqueur de parenthèse et de mots-clés est configurable dans les préférences .

Aide syntaxique dans la barre d’état

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. Cela fonctionne aussi pour les procédures , prototypes , interfaces ou fonctions importées , s’ils sont déclarés dans le même fichier source ou dans le même projet.

Options de pliage

 Quand un mot-clé de pliage est rencontré (Procedure / EndProcedure par défaut, d’autres peuvent être ajoutés) l’IDE marque la région délimitée par ces deux mots-clés par un [-] sur la ligne du premier mot et une ligne verticale jusqu’à la fin du bloc.

En cliquant sur le [-], il est possible de cacher (replier) le contenu du bloc pour garder une meilleure vue d’ensemble sur les codes sources conséquents. Le [-] se transformera alors en [+]. En cliquant de nouveau dessus, le code sera de nouveau affiché (déplié).

Note : Même si l’état des blocs est préservé lors de l’enregistrement du fichier, le fichier lui-même contient bien sûr toutes les lignes de codes. Cette option affecte seulement l’affichage du code source, pas son contenu.

Deux autres délimiteurs de replis sont activés par défaut : ” ;{” et ” ;}”. Comme ” ;” marque le début d’un commentaire en PureBasic, ils seront ignorés par le compilateur. Néanmoins, ils permettent de placer des délimiteurs à des endroits arbitraires qui ne correspondent pas forcément à un mot-clé PureBasic.

Auto-complétion

Pour ne pas avoir à se souvenir de tous les noms des commandes PureBasic, il y a l’auto-complétion qui peut rendre bien des services.

Après avoir tapé le début du nom de la commande, une liste des commandes possibles qui débute par ce mot s’affichera. Une liste de choix est aussi affichée après avoir tapé ”\” sur une variable liée à une structure ou une interface.

Une fois le mot sélectionné à l’aide des flèches il peut être inséré dans le code source en appuyant sur la touche Tab. Il est aussi possible de continuer à taper les lettres pendant que la liste est affichée, pour réduire le choix. Si plus aucune proposition n’est disponible, alors la boîte se fermera automatiquement. La touche Echappement permet de fermer la liste à tout moment. La liste se ferme aussi automatiquement si un bouton souris est utilisé dans l’IDE.

Note : Pour configurer le contenu qui sera affiché dans la liste d’auto-complétion, ainsi que ses nombreuses fonctionnalités, voir Configurer l’IDE . Par exemple, il est possible de désactiver l’apparition automatique de la liste (Ctrl+Espace sera alors necessaire pour l’afficher).

Panneau d’outils

 La plupart des outils qui rendent la navigation et l’édition de code sources plus aisés peuvent être ajoutés au panneau d’outils situé sur le côté de la zone d’édition. Pour avoir un aperçu des outils disponibles et pour les configurer, voir Les outils intégrés .

Le menu édition

Les rubriques suivantes expliquent les commandes disponibles dans le menu édition. A noter que bon nombre de ces commandes sont aussi présentes dans le menu contextuel de la zone d’édition.

Annuler

Annule la dernière action effectuée dans la zone d’édition. Il est possible d’annuler plusieurs actions à la suite.

Rétablir

Refait la dernière action annulée par la commande ”Annuler”.

Couper

Copie le texte sélectionné dans le presse-papier et le supprime du code.

Copier

Copie le texte sélectionné dans le presse-papier.

Coller

Insère le contenu du presse-papier dans le code, à la position du curseur. Si une partie du code était sélectionnée, elle sera alors remplacée par le contenu du presse-papier.

Insérer commentaires

Insère un commentaire (” ;”) au début de chaque ligne sélectionnée. Cela permet de commenter rapidement un nombre conséquent de lignes.

Supprimer commentaires

Enlève le commentaire (” ;”) du début de chaque ligne sélectionnée. Cela permet de dé-commenter rapidement un nombre conséquent de lignes. C’est la fonction inverse de ”Insérer commentaire”, mais elle fonctionne aussi sur des commentaires entrés manuellement.

Format et indentation

Reformate le code source sélectionné pour aligner le code en fonction des règles définies dans les préférences.

Sélectionner tout

Sélectionne le code source en entier.

 Aller à

Permet de se rendre directement à une ligne donnée.

Aller au mot-clé correspondant

Si le curseur est actuellement sur un mot-clé comme ”If”, le curseur ira directement sur le mot-clé correspondant (dans ce cas ”EndIf”).

Ligne récente

L’IDE garde une trace des lignes qui sont visualisées. Par exemple, si la position du curseur est changée

par la commande ”Aller à” ou en cliquant sur l’outil Navigateur de procédures , cette fonction permet de revenir rapidement à la ligne précédente. L’IDE retient 20 positions différentes.

A noter que l’enregistrement ne se fait que si le déplacement est conséquent (ex : pas si les touches

haut/bas sont utilisées).

Changer le pliage courant

Change l’état du point de repli associé à la ligne courante (le déplier ou le replier le cas échéant).

Plier/Déplier tout

Change l’état de tous les points de replis dans le code source, très utile pour cacher toutes les procédures d’un code source (ou pour ré-afficher le code complet en une seule fois).

Ajouter/Supprimer un marqueur

Cette commande permet d’ajouter un marqueur sur la ligne courante (ou de le retirer si il y en avait déjà un). Un marqueur permet de retrouver rapidement une ligne de code. Il est identifié par une petite flèche horizontale (verte, par défaut) à côté de la ligne concernée. Il est possible de passer de marqueur en marqueur en utilisant la commande ”Marqueur suivant”.

Note : Pour ajouter/retirer un marqueur à l’aide de la souris, il faut maintenir la touche Ctrl appuyée pendant le clic sur la bordure qui affiche les marqueurs (la colonne de numérotation des lignes n’est pas prise en compte).

Aller au marqueur

Se rend au premier marqueur disponible, situé en dessous de la ligne en cours d’édition. Si il n’y a plus de marqueur en dessous de cette ligne, la recherche reprend au début du code source. En utilisant le  raccourci ”Marqueur suivant” (F2, par défaut) plusieurs fois, il est possible de parcourir tous les marqueurs du code très rapidement.

Effacer les marqueurs

Retire tous les marqueurs du code source en cours d’édition.

Rechercher/Remplacer

Cette fenêtre permet de rechercher un mot (ou une suite de mots) dans le code source et de les remplacer par d’autres mots si nécessaire.

Le bouton ”Chercher suivant” démarre la recherche. La recherche peut continuer une fois un terme trouvé en utilisant la commande du menu ”Rechercher à nouveau” (raccourci F3 par défaut). Pour rendre la recherche plus pointue, les options suivantes sont disponibles :

Respecter la casse : Seul le texte qui est strictement identique au mot recherché sera retenu (les minuscules ne sont pas identiques aux majuscules).

Mots entiers seulement : Recherche seulement les termes qui forment un mot. Les termes qui contiennent le mot recherché ne seront pas retenus.

Ignorer les commentaires : Tous les commentaires PureBasic sont exclus de la recherche.

Ignorer les chaînes : Tous les contenus des strings (entre ” ”) sont ignorés.

Rechercher seulement dans la sélection : recherche seulement dans le texte sélectionné. C’est une option très utile quand elle est utilisée en conjonction avec la fonction ”Remplacer tout”. Dans ce cas, le remplacement ne s’opèrera uniquement que dans la sélection.

 En activant la case à cocher ”Remplacer par”, la fonction remplacer devient disponible. ”Chercher suivant” cherchera toujours l’occurrence suivante, et chaque clic sur le bouton ”Remplacer” remplacera le texte trouvé par le contenu du champ ”Remplacer par”.

En cliquant sur ”Remplacer tout”, tous les termes correspondants à la recherche situés en dessous du curseur seront remplacés (sauf si l’option ”Rechercher seulement dans la sélection” est activée). Rechercher suivant Continue la recherche correspondant à la dernière recherche entamée dans la fenêtre ”Chercher/Remplacer”. Rechercher précédent Continue la recherche en remontant à la recherche précédente entamée dans la fenêtre ”Chercher/Remplacer”. Rechercher dans les fichiers

 Cette fonction permet de rechercher parmi tous les fichiers d’un répertoire donné (et optionnellement dans ses sous-répertoires).

Il suffit de spécifier le mot (ou la séquence de mots) à rechercher ainsi que le répertoire de base (champ ”Répertoire”). Il est possible d’indiquer des filtres pour inclure uniquement les fichiers voulus (ex : *.pb). Plusieurs filtres peuvent être spécifiés, en les séparant par une virgule ”,” (un filtre vide ou *.* recherche dans tous les fichiers). Des options similaires à la fenêtre ”Rechercher/Remplacer” sont disponibles pour rendre la recherche plus pointue.

La case à cocher ”Inclure les sous-répertoires” permet de rechercher dans tous les sous-répertoires (d’une manière récursive) du répertoire de base.

Quand la recherche débute, une fenêtre indépendante sera ouverte pour afficher les résultats de la recherche en indiquant le fichier, le numéro de la ligne ainsi que le contenu de la ligne.

En double-cliquant sur une des lignes, le fichier sera automatiquement ouvert dans l’IDE à la ligne concernée.

Chapitre 11 Gestion de projets

L’IDE contient des fonctionnalités avancées pour gérer de larges projets. Ces fonctionnalités sont complètement facultatives, les programmes peuvent être créés et compilés sans recourir à la création d’un projet. Cependant, dès qu’un programme atteint une certaine taille et qu’il se décompose en de nombreux fichiers, il sera probablement plus facile de le gérer au sein d’un projet.

Aperçu de la gestion de projets

Un projet regroupe tous les codes sources et les autres fichiers nécessaires au programme à un seul endroit, avec un accès rapide à tous les fichiers à l’aide de l’outil de projet . Les fichiers sources inclus dans le projet peuvent être scannés automatiquement pour l’auto-complétion même s’ils ne sont pas ouverts dans l’IDE. Donc les fonctions, constantes, variables etc. du projet entier peuvent être utilisés dans l’auto-complétion. Le projet enregistre aussi les fichiers ouverts lors sa fermeture, donc l’espace de travail sera retabli à l’identique lors de la réouverture du projet.

De plus, le projet regroupe toutes les options de compilation à un seul endroit (dans le fichier du projet) et permet même de créer plusieurs cibles de compilation par projet. Une cible de compilation est un ensemble d’options permettant de générer plusieurs programmes distincts, ou plusieurs versions différentes du même programme. Toutes les cibles peuvent être compilées en une seule étape, ce qui permet de gagner en productivité.

Pour compiler un projet à partir d’un script ou d’un makefile, l’IDE accepte une option en ligne de commande pour compiler un projet sans ouvrir d’interface. Voir la section Commutateurs de la ligne de commande pour plus de détails.

Tous les noms de fichiers et les chemins d’un projet sont stockés de manière relative à son fichier de configuration, donc il est facile de déplacer ou de partager un projet, tout en gardant la structure du répertoire intacte.



Le menu Projet

 Nouveau projet

Crée un nouveau projet. Si un autre projet était déjà ouvert, il sera fermé. La fenêtre d’options sera ouverte où le nom du projet devra être saisi. La configuration du projet se fera à partir de cette fenêtre.

Ouvrir un projet

Ouvre un projet existant. Si un autre projet était déjà ouvert, il sera fermé. Les fichiers qui étaient déjà ouverts dans ce projet seront automatiquement ré-ouverts (si cette option est activée).

Projets récents

Ce sous-menu affiche la liste des projets les plus récemment ouverts.

Fermer le projet

Ferme le projet actuellement ouvert. La configuration du projet sera enregistrée et les fichiers ouverts associés au projets seront fermés (si cette option est activée).

Options du projet

Ouvre la fenêtre d’options propre au projet (voir ci-dessous pour plus d’informations)

Ajouter le fichier au projet

Ajoute le fichier courant dans le projet courant. Les fichiers qui appartiennent à un projet ont le symbole

”>” devant leur nom dans les onglets.

Retirer le fichier du projet

Retire le fichier courant du projet courant.

Ouvrir le répertoire du projet

Ouvre le répertoire qui contient le fichier projet dans l’explorateur de fichier du système.

La fenêtre d’options du projet

La fenêtre d’options du projet est le centre de configuration du projet. Les paramètres relatifs au projet et aux fichiers gérés par le projet sont accessibles ici.

 Les paramètres suivants peuvent être modifiés dans l’onglet ”Options du projet” :

Nom de fichier du projet

Affiche le nom de fichier du projet. Il ne peut être défini seulement pendant la création du projet.

Nom du projet

Nom du projet. Ce nom sera affiché dans la barre de titre de l’IDE et dans le menu ”Projets récents”.

Commentaires

Ce champ permet d’ajouter des informations complémentaires sur le projet. Elles seront affichées dans l’onglet d’information du projet.

Définir comme projet par défaut

Le projet par défaut sera ouvert automatiquement à chaque démarrage de l’IDE. Un seul projet peut être le projet par défaut. S’il n’y a pas de projet par défaut, l’IDE chargera le dernier projet qui était ouvert lors de sa fermeture (s’il y en avait un).

Fermer tous les fichiers lors de la fermeture du projet

Permet de fermer tous les fichiers qui appartiennent au projet lorsque ce dernier est fermé.

A l’ouverture du projet...

Charger tous les fichiers sources précédemment ouverts

Quand le projet est ouvert, tous les fichiers sources précédemment ouverts seront chargés.

Charger tous les fichiers sources du projet

Quand le projet est ouvert, tous les fichiers sources du projet seront chargés.

Ne charger que les fichiers sources marqués dans ’Fichiers du projet’

Quand le projet est ouvert, seuls les fichiers sources marqués dans ’Fichier du projet’ seront chargés. De cette manière, il sera possible d’avoir toujours la même configuration lorsque qu’un projet est ouvert.

Ne charger que le fichier principal du projet de la cible par défaut

Quand le projet est ouvert, seul le fichier principal de la cible par défaut sera chargé.

Ne charger aucun fichier

Aucun fichier source ne sera chargé lors de l’ouverture du projet.

L’onglet ”Fichiers du projet” affiche la liste des fichiers qui compose le projet et permet de changer leurs paramètres. L’explorateur sur la partie gauche permet de rajouter facilement des fichiers au projet.

 Les boutons en haut de l’onglet ont les fonctions suivantes :

Ajouter

Ajouter le(s) fichier(s) sélectionné(s) de l’explorateur dans le projet.

Retirer

Retire du projet les fichiers sélectionnés dans la liste.

Nouveau

Ouvre une fenêtre permettant de choisir le nom du nouveau fichier à créer. Ce fichier sera créé, ajouté au projet et ouvert dans l’IDE.

Ouvrir

Ouvre une fenêtre permettant de choisir un fichier existant à ajouter au projet. Le fichier sera automatiquement ouvert dans l’IDE.

Voir

Ouvre le(s) fichier(s) sélectionné(s) de la liste dans l’IDE, ou dans le visualisateur de fichiers

si ce sont des fichiers binaires.

 Les cases à cocher en dessous de la liste des fichiers représentent les options disponibles pour chaque fichier. Elles peuvent être changées pour un seul ou plusieurs fichiers à la fois. Voici leurs descriptions :

Changer le fichier à l’ouverture du projet

Indique à l’IDE de charger ce fichier lorsque que le projet est ouvert et que l’option ”Ne charger que les fichiers sources marqués dans ’Fichiers projet”’ est activée dans l’onglet ”Options du projet”.

Afficher une alerte si le fichier a été modifié

Quand le projet est fermé, l’IDE calcule un checksum de tous les fichiers qui ont cette option activée, et affichera une alerte si le fichier a été modifié en dehors de l’IDE. Cela permet de savoir qu’une modification externe a eu lieu lorsque l’on partage des fichiers avec différents projets. Cette option ne devrait pas être activée pour les fichiers binaires imposants pour garder une bonne rapidité d’ouverture et de sauvegarde du projet.

Scanner le fichier pour l’auto-complétion

Active le scan du fichier pour la liste d’auto-complétion, même si ce dernier n’est pas chargé dans l’IDE. Cette option est activée par défaut pour tous les fichiers non-binaires. Il faudra le désactiver pour tous les fichiers qui ne contiennent pas de code source, ainsi que pour les fichiers qui n’ont pas leurs places dans la liste d’auto-complétion.

Afficher le fichier dans le panneau de projet

Affichera le fichier dans le panneau de projet, qui se trouve à droite de l’éditeur. Si le projet a beaucoup de fichiers, il peut être utile d’en cacher quelques-un pour garder un accès rapide aux fichiers principaux.

Résumé du projet

Quand un projet est ouvert, le premier onglet des fichiers affiche un résumé du projet et de ses fichiers.

 Informations du projet

Cette section affiche les informations générales du projet, comme le nom du projet, ses commentaires ou quand le fichier a été ouvert pour la dernière fois.

Fichiers du projet

 Cette section affiche tous les fichiers du projet et leurs paramètres. Un double-clic sur un de ces fichiers l’ouvre automatiquement dans l’IDE. Un clic-droit fait apparaître un menu contextuel avec davantage d’options :

Ouvrir - Ouvre le fichier dans l’IDE.

Ouvrir avec le visualisateur de fichiers - Ouvre le fichier dans le visualisateur intégré de l’IDE. Ouvrir avec l’explorateur - Ouvre le fichier dans l’explorateur du système d’exploitation. Ajouter un nouveau fichier - Ajoute un nouveau fichier au projet. Retirer du projet - Retire le(s) fichier(s) sélectionné(s) du projet. Rafraîchir les données de l’auto-complétion - Rescanne tous les fichiers du projet pour actualiser les données de l’auto-complétion.

Cibles du projet

Cette section affiche toutes les cibles du projet et quelques un de leurs paramètres. Un double-clic sur l’une des cibles l’ouvre dans les options de compilation . Un clic-droit affiche un menu contextuel avec davantage d’options :

Editer la cible - Ouvre la cible dans la fenêtre options de compilation. Définir comme défaut - Défini cette cible comme celle par défaut.

Inclure dans ’Créer toutes les cibles’ - Inclut cette cible dans ’Créer toutes les cibles’.

La panneau projet

Un outil intégré permet d’accéder rapidement aux fichiers du projet. Pour plus d’informations voir la section outils intégrés .

 Chapitre 12

Compilation d’un programme

La compilation d’un programme est facile, il suffit de sélectionner ’Compiler/Executer’ (raccourcis F5 par défaut) et le code sera compilé et exécuté.

Les ”Options de compilation” permettent de paramétrer le processus de compilation. Les choix effectués sont associés au fichier ou au projet courant et sont persistants, même quand ils sont fermés. Par défaut ces paramètres sont écrits à la fin du fichier, sous forme de commentaires (invisibles quand le fichier est chargé par l’IDE). Il est possible de changer cet emplacement si, par exemple, un outil de gestion de versions tel que CVS est utilisé (pour éviter les conflits entre les utilisateurs qui auront chacun leurs propres paramètres en fin de fichier).

Si une erreur est rencontrée lors de la compilation, un message sera affiché en indiquant la ligne incriminée. Ce message sera aussi ajouté dans le rapport d’activité.

Le menu ”Compilateur”

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/Exécuter” 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.

Vérification de la syntaxe

 Vérifie la syntaxe du code.

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.

Redémarrer 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 du Compilateur...

Ouvre la fenêtre d’options, qui permet d’ajuster les paramètres concernant la compilation du code source en cours d’édition.

Créer un éxecutable...

Ouvre une boîte de dialogue de sauvegarde, demandant le nom de l’exécutable à créer. Si le format exécutable est réglé sur DLL, il créera une DLL sous Windows, un objet partagé sous Linux et une dylib sous OS X. Lorsque vous créez un fichier exécutable sous OS X, en ajoutant ’. App ’au nom de l’exécutable créera un fichier exécutable fourni avec la structure de répertoires nécessaires, y compris l’icône. Si aucun ’. App’ n’est défini, il va créer un exécutable standard de type console.

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.

Utiliser Compilateur

Cette option permet de sélectionner un compilateur différent de la version actuelle de PureBasic. Cela facilite la compilation d’un programme sous différentes achitectures (x86 ou x64) sans avoir à redémarrer une nouvelle instance de l’IDE. Les compilateurs additionnels sont paramétrables dans les préférences . Si la version du compilateur est identique à celle de l’IDE mais que le processeur géré est différent, le débogueur intégré peut quand même être utilisé pour déboguer cet exécutable. Par exemple, une exécutable compilé avec la version x86 du compilateur peut être débogué avec l’IDE x64 et vice versa. Si la version du compilateur et de l’IDE ne correspondent pas, alors le débogueur indépendant sera utilisé pour éviter des problèmes potentiels.

Utiliser une icône (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).

Windows : L’icône doit être au format ICO (icônes Windows).

MacOS X : Le fichier icône doit être au format ICNS (icônes Macintosh). Pour créer un tel fichier, il faut 4 fichiers PNG de dimensions 128x128, 48x48, 32x32 et 16x16 de l’image qui sera utilisée pour l’icône. Ensuite l’outil ”Icon Composer” fourni avec les outils de développement Apple servira à créer le fichier final (il devrait se trouver dans le dossier : /Developer/Applications/Utilities/). Il sera peut-être nécessaire de redémarrer l’explorateur (Finder) pour l’afficher.

Activer la colorisation des mots clés assembleur

Active la colorisation des mots clés de l’assembleur. Voir la section Assembleur en ligne x86 pour plus d’informations.

Activer la gestion des 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 numéro de ligne pour 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.

Activer le support des thèmes (Uniquement pour Windows)

Ajoute un fichier permettant la gestion des thèmes Windows (fenêtres et gadgets skinées), lorsque le programme est exécuté sur Windows XP, Windows Vista, Windows 7, Windows 8 (fortement recommandé) ou Windows 10.

L’application nécessite les droits administrateurs (Windows Vista et suivants) (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 et suivants. (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. L’application ne nécessite aucun droits particuliers (Windows Vista et suivants) (Windows seulement)

Cette option désactive la «virtualisation» de cet exécutable sur Windows Vista et suivants. 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.

bibliothèque Sous-système

Il est possible d’utiliser différents sous-systèmes lors de la compilation. Plus d’un sous-système peut être spécifié, séparés par un espace. Pour plus d’informations, consultez sous-systèmes .

Format de l’exécutable

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êtres, 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 qui 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écifique). 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 proposent.

Fichier d’options du Linker

Un fichier texte peut être spécifié ici avec de nouvelles options de ligne de commande à transmettre à l’éditeur de liens lors de la création de l’exécutable. Le fichier doit contenir une option par ligne.

Compiler/Exécuter

Cette section contient des options qui affectent la façon dont l’exécutable est exécuté à partir de l’IDE pendant les tests. Sauf pour l’option ’outils’, ils n’ont aucun effet quand le menu ”Créer un exécutable” est utilisé.

 Activer le Débogueur

Définit l’état du débogueur (on/off) pour le code source en cours, ou si l’option du fichier principal est utilisé, pour ce fichier aussi. On peut utiliser directement le menu du débogueur

Activer le Purifier

Active le purificateur du débogueur. Le purificateur peut détecter certains types d’erreurs de programmation comme écrire au delà des capacités d’un tampon en mémoire. Voir outils de débogage interne pour plus de détails.

Débogueur à utiliser

Permet de choisir un type de débogueur différent pour le fichier en cours uniquement. Si cette option est

désactivée, le débogueur par défaut est utilisé, c’est celui spécifié dans les préférences .

Utiliser le mode avertissement

Permet d’ignorer, d’afficher ou de traiter les avertissements.

Paramètre de l’éxecutable

La chaîne donnée ici sera passée en tant que ligne de commande pour le programme lorsqu’il est exécuté à partir de l’IDE.

Répertoire courant

Le répertoire spécifié ici sera défini comme le répertoire courant pour le programme lorsqu’il est exécuté à partir de l’IDE.

Créer l’exécutable temporaire dans le répertoire source

Avec cette option activée, le fichier exécutable temporaire sera placé à l’intérieur du répertoire source.

Cela peut être utile si le programme dépend de fichiers à l’intérieur du répertoire source. Avec cette option désactivée, l’exécutable est créé dans le répertoire temporaire de système.

Outils à exécuter

Des outils externes peuvent être activés. La colonne ”Paramètres globaux” indique si l’outil est activé ou désactivé dans la configuration des outils . Un outil ne sera exécuté pour la source que s’il est à la fois activé globalement et pour la source en cours.

Remarque : Pour qu’un outil puisse être énuméré ici, il doit avoir l’option ”Activer l’outil sur une base per-source” dans la configuration des outils et être exécuté par un déclencheur qui est associé à un fichier source. (c.-à-pas par le menu de démarrage ou de l’éditeur par exemple)

Constantes

Dans cette section, un ensemble de constantes spéciales pour l’éditeur aussi bien que des constantes personnalisées peuvent être définies 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 utilisateurs

Les constantes personnalisées peuvent être définies et facilement activé / désactivé avec les cases à cocher. Les constantes devraient être ajoutées à mesure qu’elles apparaissent dans le code source. Cela fournit un moyen pour activer / désactiver certaines fonctionnalités dans un programme et on peut activer / désactiver ces fonctionnalités avec CompilerIf/CompilerEndIf .

Dans la définition de ces constantes, les variables d’environnement peuvent être utilisées dans un style ”bash” avec un ”$” devant. La variable d’environnement sera remplacée par la définition avant de compiler le source.

Exemple: #Creator=$USERNAME



Ici,le $USERNAME sera remplacé par le nom de l’utilisateur connecté sur les systèmes Windows. Si une variable d’environnement n’existe pas, elle sera remplacée par une chaîne vide.

Note : Pour tester dans le code source si une constante est définie ou non, la fonction Defined() dans fonction du compilateur peut être utilisée.

 Informations de version

 Pour Windows seulement : 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 :

OS du fichier

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

Les valeurs des champs sont accessibles lors de la compilation du programme de l’IDE en utilisant les constantes suivantes (même ordre) :

#PB_Editor_FileVersionNumeric

#PB_Editor_ProductVersionNumeric

#PB_Editor_CompanyName #PB_Editor_ProductName #PB_Editor_ProductVersion

 #PB_Editor_FileVersion #PB_Editor_FileDescription #PB_Editor_InternalName #PB_Editor_OriginalFilename #PB_Editor_LegalCopyright #PB_Editor_LegalTrademarks #PB_Editor_PrivateBuild #PB_Editor_SpecialBuild #PB_Editor_Email #PB_Editor_Website

Ressources

Pour Windows seulement : 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 accessibles 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 renseignements 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 exécutable. 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 ”Exécutable 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 fichier (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 statuts. Quand le processus de compilation est fini, le log peut être copié dans le presse-papier ou enregistré sur le disque.

 Chapitre 13 Utiliser le débogueur

PureBasic est fourni avec un puissant débogueur pour trouver rapidement les erreurs et les bugs des programmes. Il permet de contrôler le flux d’exécution du programme, d’observer le contenu des variables, tableaux et listes, d’afficher des informations de débuggage etc. Il supporte aussi des fonctions avancées tels que l’affichage du contenu des registres (assembleur), voir le contenu de la pile ou d’une zone de mémoire quelconque. De plus il permet de faire du déboguage à distance, via le réseau. Pour activer le débogueur, il suffit de choisir ”Utiliser le débogueur” dans menu ”Débogueur” (ou de l’activer dans les ”Options de compilation”). En choisissant le menu ”Compiler avec le débogueur”, le débogueur sera activé seulement pour une compilation.

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. Il propose quasiment toutes les fonctionnalités du débogueur intégré, mais parce qu’il est séparé de l’IDE, la rapidité des commandes est légèrement diminuée.

De plus il permet de déboguer un programme à distance, via le réseau.

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.

Le type de débogueur à utiliser est sélectionnable dans les préférences.

Bien entendu, quand un programme utilise le débogueur, il fonctionne bien plus lentement. Cela ne devrait pas poser de problèmes majeurs étant donné que la rapidité est toujours acceptable, et que ce mode est utilisé uniquement pendant le développement.

Si quelques parties du programme ont déjà été testées et nécessitent une rapidité maximale même pendant les phases de déboguages, il est possible d’utiliser les directives de compilation DisableDebugger et EnableDebugger autour de ces parties.

 Le débogueur intégré

 Toutes les commandes relatives au débogueur lorsqu’un programme est en cours d’exécution sont disponibles à partir du menu ”Débogueur” (ou de la barre d’outils et des raccourcis claviers).

Tant que le programme est en cours de débuggage, tous les fichiers sources qui sont en rapport avec ce programme sont verrouillés en lecture seule jusqu’à la fin de son exécution. Ceci est fait pour assurer que le code qui sera affiché lors du ’pas à pas’ ou lors d’une erreur sera correct (et qu’il n’a pas été édité entre temps sans avoir été recompilé).

A noter qu’un programme ne peut être débogué qu’une seule fois par le débogueur intégré. Si le même programme est de nouveau compilé pour être debuggé, le débogueur indépendant sera utilisé. Par contre il est possible de déboguer plusieurs programmes différents simultanément avec le débogueur intégré. Astuce

Sous Windows, le menu ”Débogueur” est aussi ajouté au menu système de la fenêtre principale de l’IDE (le menu qui apparaît lors d’un click sur l’icône située dans le coin supérieur gauche de la fenêtre). Cela permet aussi d’accéder à ce menu à partir de la barre des tâches, en cliquant avec le bouton de droite de la souris sur l’icône correspondant à l’IDE.

Controle de l’exécution

Ces fonctions permettent le contrôle sur le déroulement du programme en cours de débuggage. Le programme peut être stoppé, exécuté pas à pas (ligne par ligne), examiné (voir le contenu des variables à cet instant etc.). Quand le programme est stoppé, la ligne qui va être exécutée est marquée (par défaut en bleu clair) dans le code source correspondant.

L’état du programme est indiqué dans la barre d’état de l’IDE et dans le rapport d’activité.

Commandes du menu permettant le contrôle du programme:

Stop

Stoppe l’exécution du programme et affiche la ligne qui va être exécutée.

Continue

Reprend l’exécution du programme, de manière normale.

Tuer le programme

Force le programme à se terminer et ferme toutes les fenêtres de débuggage associées à ce programme. Pas

Exécute la ligne du programme actuellement affichée et stoppe de nouveau l’exécution.

Pas <n>

Exécute le nombre de lignes indiqué et stoppe l’exécution du programme.

Passer au-delà

Exécute la ligne du programme actuellement affichée et stoppe de nouveau l’exécution, comme un ’Pas’ normal. La différence survient si la ligne contient un ou plusieurs appels à des procédures . Dans ce cas, les procédures seront toutes exécutées, sans arrêt, contrairement au mode ’Pas’ qui rentre dans chaque procédure. Ceci permet de passer rapidement sur des procédures qui sont connues comme étant correctes. Sortir

Exécute le reste du code de la procédure en cours d’exécution et s’arrête à sa sortie. Si la ligne courante n’est pas dans une procédure, un ’Pas’ normal sera fait.

Points d’arrêt (ligne)

Les points d’arrêt sont une autre manière de contrôler l’exécution d’un programme. Avec la commande ”Point d’arrêt” du menu, la ligne courante sera considérée comme un point d’arrêt (ou retire le point d’arrêt si cette ligne en était un). Quand le programme atteint un point d’arrêt, alors l’exécution est stoppée sur cette ligne (la ligne n’a pas encore été exécutée). A noter que si le point se trouve sur une ligne ou aucun code n’est exécutable (commentaire, ligne vide, structure etc.), le programme s’arrêtera sur la prochaine ligne exécutable rencontrée.

Un fois que l’exécution du programme a été interrompue par un point d’arrêt, il est possible d’utiliser n’importe quelle commande du ”Contrôle de l’exécution” pour continuer à déboguer le programme. Les points d’arrêts peuvent être ajoutés ou retirés de manière dynamique pendant l’édition ou pendant l’exécution du programme. La commande ”Effacer les points d’arrêt” permettent d’enlever tous les points d’arrêt du fichier source en cours d’édition.

Note : Pour ajouter/retirer un point d’arrêt à l’aide de la souris, il faut maintenir la touche ’Alt’ appuyée pendant le clic sur la bordure qui affiche les points d’arrêts (la colonne de numérotation des lignes n’est pas prise en compte).

Points d’arrêts (conditionnel)

En plus des points d’arrêts classiques, le débogueur permet d’arrêter l’exécution du programme si une condition donnée est remplie. Par exemple, il est possible de mettre une condition sur la valeur d’une variable et d’arrêter le programme quand elle atteint une certaine limite. La condition prend la forme d’une expression PureBasic évaluable en vrai ou faux. Tout ce que l’on peut mettre après un If, y compris les opérateur logiques tels que And, Or ou Not est accepté. La plupart des fonctions des bibliothèques Math , Memory et String ainsi que toutes les fonctions de validation de la forme IsXxx() and the XxxID sont disponibles.



Exemples de conditions :

MaVariable$ <> "Salut" Or Compteur < 0 ; arrête l’execution si ’MaVariable$ ’ n’est plus égale à "Salut" ou si ’Compteur ’ devient inférieur à zéro

PeekL(*UneAdresse+500) <> 0               ; arrête l’exécution la valeur de type long contenu à l’adresse données n’est plus égale à zéro

Un point d’arrêt conditionnel peut être ajouté via l’entrée ”Point d’arrêt conditionnel” du menu ”Debogueur”. Il peut se limiter à une procedure particulière, ou il peut être ajouté pour tout le code source. L’entrée ”Principal” dans la selection des procédures indique que le point d’arrêt conditionnel devra être évalué seulement en dehors des procédures.

La colonne ’status’ affiche le résultat de tous les points d’arrêt conditionnels après leur dernière évaluation. Cela peut être ’vrai’, ’faux’ ou ’error’ si la condition n’est pas une expression valide. Dès qu’une condition est vraie, alors l’exécution du programme s’arrête. Cette condition est automatiquement enlevée de la liste, donc si le programme continue, il ne s’arrêtera pas immédiatement. Note : La vérification des points d’arrêt conditionnels ralentit l’exécution du programme car les expressions doivent être évaluées à chaque ligne de code. Il vaut mieux les déclarer uniquement quand c’est vraiment nécessaire, pour garder une exécution rapide du programme. Le fait de limiter un point d’arrêt conditionnel à une procédure permet aussi de limiter l’impact sur la rapidité d’exécution, car l’expression n’est évaluée que lorsque la procédure est appelée.

Variables en cours d’exécution

La valeur d’une variable peut être très rapidement vue pendant que le programme est en cours d’exécution en plaçant le curseur de la souris dessus un bref instant dans le code source. Si la variable est actuellement dans la portée et peut être affichée, sa valeur sera affichée dans une info-bulle.

 Les expressions plus complexes (par exemple les champs de tableau array ) peuvent être consultées en les sélectionnant avec la souris et en plaçant le curseur de la souris sur la sélection.

Des outils du Debogueur offrent également un certain nombre de façons d’examiner le contenu des variables , tableaux ou des listes .

Erreurs dans le programme

Si le débogueur rencontre une erreur dans le programme en cours de débuggage, il arrêtera l’exécution et marquera la ligne qui contient l’erreur (par défaut en rouge) et affichera le message d’erreur dans la barre d’état et le rapport d’activité.

A ce moment, il est toujours possible de regarder le contenu des variables, de la mémoire et l’historique des appels des procédures, mais les autres fonctionnalités telles que l’affichage des registres ou l’état de la pile ne sont plus disponibles.

Si l’erreur est considérée comme fatale (comme un accès interdit à une zone mémoire ou une division par 0) il ne sera pas possible de continuer l’exécution du programme. Par contre, si l’erreur est reportée par une commande PureBasic, il est possible de continuer tout de même l’exécution du programme, mais dans ce cas d’autres erreurs anormales peuvent apparaître.

Après une erreur (même fatale), la commande ”Tuer le programme” doit etre utilisée pour finir l’exécution du programme et reprendre l’édition du code source. Le programme n’est pas automatiquement tué après une erreur pour permettre au développeur d’utiliser les fonctionnalités du débogueur (comme examiner le contenu des variables) pour essayer de détecter la cause de l’erreur. Note : il est possible de paramétrer le débogueur pour qu’il termine automatiquement l’exécution du programme en cas d’erreur (voir Paramétrer l’IDE).

Le rapport d’activité

Le rapport d’activité est utilisé pour l’affichage des erreurs de compilation, ainsi que des messages survenant durant le débuggage. Les messages sont toujours affichés dans le rapport d’activité du fichier concerné, donc si une erreur survient dans un fichier inclus, ce dernier sera affiché et un message ajouté dans son rapport d’activité.

Le sous-menu ”Rapport d’activité” du menu ”Débogueur” contient les commandes pour sa gestion: Afficher/Cacher

Affiche ou cache le rapport d’activité pour le fichier en cours d’édition.

Effacer

Efface toutes les lignes du rapport d’activité du fichier en cours d’édition.

Copier

Copie le contenu du rapport d’activité dans le presse-papier.

Effacer les erreurs

Une fois que le programme a été tué, les erreurs affichées dans le code sources restent afin de repérer facilement les lignes qui ont causé des problèmes et de les corriger. Cette commande permet d’enlever le surlignage sur les lignes d’erreur. Il est aussi possible de configurer l’IDE pour ôter automatiquement le surlignage des erreurs lorsque le programme se termine (voir Paramétrer l’IDE )



219