Manual Codeblocks FR

Code::Blocks
Manuel Utilisateur
Version 2.0.1 beta
Merci à l’équipe Code::Blocks:
Anders F. Björklund (afb), Biplab Kumar Modak (biplab), Bartomiej wiecki (byo), Paul
A. Jimenez (ceniza), Koa Chong Gee (cyberkoa), Daniel Orb (daniel2000), Lieven de Cock
(killerbot), Yiannis Mandravellos (mandrav), Mispunt (mispunt), Martin Halle (morten-
macfly), Jens Lody (jens), Jerome Antoine (dje), Damien Moore (dmoore), Pecan Heber
(pecan), Ricardo Garcia (rickg22), Thomas Denk (thomasdenk), tiwag (tiwag), stahta01
(stahta01), oBFusCATed (oBFusCATed), BlueHazzard (BlueHazzard)
Et bien d’autres contributeurs...
Manuel original en Anglais et en Allemand (V1.x) par Mario Cupelli (mariocup)
Traduction de la version originale anglaise et corrections/ajouts dans la version 2 par
Gérard Durand (gd on).
Il est permis de copier, distribuer et/ou modifier ce document dans le respect de la licence
”GNU Free Documentation”, Version 1.2 ou toute autre version postérieure publiée par
la ”Free Software Foundation”.
mis à jour en octobre 2020
Table des Matières
1 Gestion de Projet Code::Blocks 5
1.1 Vue du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2 Notes pour les Projets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3 Modèles de Projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.4 Créer des Projets à partir de Cibles de Génération . . . . . . . . . . . . . . 8
1.5 Cibles Virtuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.6 Étapes Pré- et Post Génération . . . . . . . . . . . . . . . . . . . . . . . . 9
1.7 Ajouter des Scripts à des Cibles de Génération . . . . . . . . . . . . . . . . 9
1.8 Espace de travail et Dépendances de Projet . . . . . . . . . . . . . . . . . 10
1.9 Inclure des Fichiers en Assembleur . . . . . . . . . . . . . . . . . . . . . . 10
1.10 Éditeur et Outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.10.1 Code par Défaut . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.10.2 Abréviations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.10.3 Personnalités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.10.4 Fichiers de Configuration . . . . . . . . . . . . . . . . . . . . . . . . 12
1.10.5 Navigation et Recherche . . . . . . . . . . . . . . . . . . . . . . . . 13
1.10.6 Vue des Symboles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.10.7 Inclure des Fichiers d’Aide Externes . . . . . . . . . . . . . . . . . . 17
1.10.8 Inclure des outils externes . . . . . . . . . . . . . . . . . . . . . . . 19
1.11 Astuces pour travailler avec Code::Blocks . . . . . . . . . . . . . . . . . . . 20
1.11.1 Recherche de Modifications . . . . . . . . . . . . . . . . . . . . . . 20
1.11.2 Échange de données avec d’autres applications . . . . . . . . . . . . 20
1.11.3 Configurer les variables d’environnement . . . . . . . . . . . . . . . 21
1.11.4 Basculer entre diverses dispositions . . . . . . . . . . . . . . . . . . 22
1.11.5 Basculer entre projets . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.11.6 Configurations étendue des compilateurs . . . . . . . . . . . . . . . 23
1.11.7 Zoomer dans l’éditeur . . . . . . . . . . . . . . . . . . . . . . . . . 24
1.11.8 Mode de Repliement . . . . . . . . . . . . . . . . . . . . . . . . . . 24
1.11.9 Sélection de modes dans l’éditeur . . . . . . . . . . . . . . . . . . . 24
1.11.10 Repliement de code . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.11.11 Auto complétion . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
1.11.12 Recherche de fichiers cassés . . . . . . . . . . . . . . . . . . . . . . 26
1.11.13 Inclure des librairies . . . . . . . . . . . . . . . . . . . . . . . . . . 26
1.11.14 Ordre d’édition de liens des fichiers objets . . . . . . . . . . . . . . 26
1.11.15 Sauvegarde automatique . . . . . . . . . . . . . . . . . . . . . . . . 27
1.11.16 Configuration des extensions de fichiers . . . . . . . . . . . . . . . . 27
1.12 Code::Blocks en ligne de commande . . . . . . . . . . . . . . . . . . . . . . 27
1.13 Raccourcis Clavier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
1.13.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
1.13.2 Fonctionnalités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
1.13.3 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
1.13.4 Éditeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
1.13.5 Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.13.6 Vue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Code::Blocks V2.0.1 beta Table des Matières
1.13.7 Recherche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.13.8 Générer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
1.13.9 Debug . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2 Extensions 34
2.1 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.2 Astyle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.3 AutoVersioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.3.3 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
2.3.4 Onglets de la boı̂te de dialogue . . . . . . . . . . . . . . . . . . . . 37
2.3.5 Inclusion dans votre code . . . . . . . . . . . . . . . . . . . . . . . . 41
2.3.6 Générateur de journal des changements . . . . . . . . . . . . . . . . 42
2.4 Browse Tracker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
2.5 CodeSnippets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
2.6 Doxyblocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
2.7 Extension Editor Tweaks . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
2.8 Extensions FileManager et PowerShell . . . . . . . . . . . . . . . . . . . . 50
2.9 Éditeur Hexadécimal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
2.10 Recherche Incrémentale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
2.11 Extension NassiShneiderman . . . . . . . . . . . . . . . . . . . . . . . . . . 57
2.11.1 Création d’un diagramme . . . . . . . . . . . . . . . . . . . . . . . 57
2.11.2 Édition de structogrammes . . . . . . . . . . . . . . . . . . . . . . . 59
2.12 LibFinder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
2.12.1 Recherche de librairies . . . . . . . . . . . . . . . . . . . . . . . . . 60
2.12.2 Inclure des librairies dans les projets . . . . . . . . . . . . . . . . . 62
2.12.3 Utilisation de LibFinder dans des projets générés par des assistants 63
2.13 Extension SpellChecker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
2.13.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
2.13.2 Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
2.13.3 Dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
2.13.4 Fichiers Thésaurus . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
2.13.5 Bitmaps (Drapeaux) . . . . . . . . . . . . . . . . . . . . . . . . . . 65
2.13.6 Styles à vérifier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
2.14 Exporter du code Source . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
2.15 Support de SVN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
2.16 Liste des ”à faire” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
2.17 Tools+ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
2.17.1 Exemple d’Outils Tools+ . . . . . . . . . . . . . . . . . . . . . . . . 72
2.18 Thread Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
2.18.2 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
2.18.3 Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
2.18.4 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
2.18.5 Options de Thread search (ou Tâche de Recherche) . . . . . . . . . 78
2.18.6 Mise en page . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Code::Blocks 2
2.18.7 Panneau de Gestion . . . . . . . . . . . . . . . . . . . . . . . . . . 79

2.18.8 Type de journal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
2.18.9 Mode de partage de fenêtre . . . . . . . . . . . . . . . . . . . . . . 79
2.18.10 Tri des résultats de recherche . . . . . . . . . . . . . . . . . . . . . 79
2.19 Code statistics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
2.20 Profilage de Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
2.21 Importation de Projets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
2.22 Recherche de Code Source Disponible . . . . . . . . . . . . . . . . . . . . . 80
2.23 Extension Symbol Table . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
3 Expansion de Variables 82
3.1 Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
3.2 Liste des variables internes . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
3.2.1 Espace de travail Code::Blocks . . . . . . . . . . . . . . . . . . . . . 83
3.2.2 Fichiers et répertoires . . . . . . . . . . . . . . . . . . . . . . . . . . 83
3.2.3 Cibles de génération . . . . . . . . . . . . . . . . . . . . . . . . . . 84
3.2.4 Langue et encodage . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
3.2.5 Heure et date . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
3.2.6 Dépendant de la Plateforme . . . . . . . . . . . . . . . . . . . . . . 85
3.2.7 Commandes du Système d’exploitation . . . . . . . . . . . . . . . . 85
3.2.8 Valeurs aléatoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
3.2.9 Chemins Standard . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
3.2.10 Fonctions internes pour la conversion de chemins . . . . . . . . . . 86
3.2.11 Évaluation Conditionnelle . . . . . . . . . . . . . . . . . . . . . . . 87
3.3 Expansion de script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
3.4 Macros Commandes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
3.5 Compilation d’un fichier unique . . . . . . . . . . . . . . . . . . . . . . . . 89
3.6 Édition de liens de fichiers objets en exécutable . . . . . . . . . . . . . . . 89
3.7 Variables globales du compilateur . . . . . . . . . . . . . . . . . . . . . . . 89
3.7.1 Synopsis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
3.7.2 Noms et Membres . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
3.7.3 Contraintes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
3.7.4 Utilisation des Variables Globales du Compilateur . . . . . . . . . . 91
3.7.5 Ensembles de Variables . . . . . . . . . . . . . . . . . . . . . . . . . 91
3.7.6 Mini-Tutoriel de membres utilisateur . . . . . . . . . . . . . . . . . 92
4 Travailler avec Code::Blocks 94

4.1 Le processus de génération de Code::Blocks . . . . . . . . . . . . . . . . . . 94
4.1.1 Étapes successives de la Génération . . . . . . . . . . . . . . . . . . 94
4.1.2 Espace de Travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
4.1.3 Projets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
4.1.4 Génération de Cibles . . . . . . . . . . . . . . . . . . . . . . . . . . 96
4.1.5 Phase de Preprocessing . . . . . . . . . . . . . . . . . . . . . . . . . 96
4.1.6 Commandes réelles d’exécution . . . . . . . . . . . . . . . . . . . . 97
4.1.7 Étape de pré-génération et post-génération . . . . . . . . . . . . . . 97
4.2 Création d’un Nouveau Projet . . . . . . . . . . . . . . . . . . . . . . . . . 98
4.2.1 L’assistant de Projet . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Code::Blocks 3
4.2.2 Changer la composition du fichier . . . . . . . . . . . . . . . . . . . 100

4.2.3 Modifier les Options de Génération . . . . . . . . . . . . . . . . . . 104
4.3 Débogage avec Code::Blocks . . . . . . . . . . . . . . . . . . . . . . . . . . 107
4.3.1 Générer une version ”Debug” de votre Projet . . . . . . . . . . . . 107
4.3.2 Ajout de Témoins . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
4.3.3 Double-clic dans la fenêtre de pile d’Appels . . . . . . . . . . . . . 110
4.3.4 Activer des Points d’Arrêt . . . . . . . . . . . . . . . . . . . . . . . 111
4.3.5 Notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
4.4 Scripts du Débugueur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
4.4.1 Principe de Base des scripts du débugueur . . . . . . . . . . . . . . 114
4.4.2 Fonctions Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
4.5 Code::Blocks et les Makefiles . . . . . . . . . . . . . . . . . . . . . . . . . . 117
4.5.1 Article du Wiki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
4.5.2 Compléments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
4.6 Utilitaire Cbp2make . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
4.6.1 À propos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
4.6.2 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
4.6.3 Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
4.6.4 Syntaxe de la Ligne de Commande . . . . . . . . . . . . . . . . . . 124
4.7 Internationalisation de l’interface de Code::Blocks . . . . . . . . . . . . . . 127
5 Installation et Configuration de CodeBlocks avec MinGW 130

5.1 Installation de la dernière version officielle de Code::Blocks sous Windows . 130
5.2 Configurer MinGW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
5.2.1 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
5.2.2 La chaı̂ne d’outils de compilation MinGW . . . . . . . . . . . . . . 131
5.2.3 Configuration de Code::Blocks . . . . . . . . . . . . . . . . . . . . . 133
5.3 Version Nightly de Code::Blocks sous Windows . . . . . . . . . . . . . . . 135
6 Générer CodeBlocks à partir des Sources 138

6.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
6.2 Windows ou Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
6.2.1 Système de génération initial . . . . . . . . . . . . . . . . . . . . . . 140
6.2.2 Système de Contrôle de Versions . . . . . . . . . . . . . . . . . . . 140
6.2.3 wxWidgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
6.2.4 Zip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
6.2.5 Espace de Travail - Workspace . . . . . . . . . . . . . . . . . . . . . 144
6.2.6 Générer Codeblocks . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
6.2.7 Générer seulement les plugins . . . . . . . . . . . . . . . . . . . . . 147
URL catalog 149
Code::Blocks 4
1 Gestion de Projet Code::Blocks
Les textes de plusieurs paragraphes (par exemple chapitre 3 à la page 82 ou chapitre 2 à la
page 34) sont les documentations officielles du site Wiki de Code::Blocks (éventuellement
revues et complétées) où elles ne sont disponibles qu’en anglais. Cette documentation est
une extension de la version originale 1.1, assemblée et/ou écrite par Mario Cupelli.
Note :
Remarque du traducteur : Les références aux menus sont traduites en
français. Cela suppose donc que vous avez installé la francisation de
l’interface de Code::Blocks que vous pouvez obtenir, notamment via le
forum, dans la rubrique CodeBlocks Translation. Ne plus utiliser celle
du site original LaunchPad bien trop ancienne et largement dépassée.
Utiliser plutôt une nouvelle version, aussi sur Launchpad, via https:
//launchpad.net/codeblocks-gd. Les images ci-dessous sont celles
de la documentation originale, en anglais
L’illustration ci-dessous montre l’apparence de la fenêtre de l’interface utilisateur de

Code::Blocks.
Figure 1.1: Environnement de développement Intégré (IDE) de Code::Blocks

Code::Blocks V2.0.1 beta
Gestion Cette fenêtre contient l’interface ’Projets’ qui dans le texte suivant sera référencée
comme vue du projet. Cette vue affiche tous les projets ouverts dans Code::Blocks
à un instant donné. L’onglet ’Symboles’ de la fenêtre Gestion affiche les symboles,
les variables etc.
Éditeur Dans l’illustration ci-dessus, un fichier source nommé hello.c est ouvert avec
colorisation de syntaxe dans l’éditeur.
Liste des fichiers ouverts affiche une liste de tous les fichiers ouverts dans l’éditeur, dans
cet exemple : hello.c.
CodeSnippets peut être affiché via le menu ’Vue’ →’ CodeSnippets’ . Ici vous pouvez
gérer des modules de texte, des liens vers des fichiers et des liens vers des urls.
Journaux & autres . Cette fenêtre est utilisée pour sortir des résultats de recherche, des
messages envoyés par un compilateur etc..
La barre d’état donne un aperçu des paramétrages suivants :
Chemin absolu d’un fichier ouvert dans l’éditeur.
L’éditeur utilise l’encodage par défaut de votre système d’exploitation. Cette con-
figuration sera affichée par défaut.
Numéros de ligne et de colonne de la position actuelle du curseur dans l’éditeur.
Le mode de configuration du clavier pour insérer du texte (Insertion ou Remplace-
ment).
État actuel du fichier. Un fichier modifié sera marqué comme Modie sinon cette
case reste vide.
Autorisation d’un fichier. Un fichier qui est en lecture seule sera affiché Lecture seule
dans la barre d’état. Dans la fenêtre ’Ouvrir la liste de fichiers’ ces fichiers seront
identifiés par une icône de verrouillage superposée.
Note :
Dans l’éditeur courant, l’utilisateur peut choisir les propriétés du
menu de contexte. Dans le dialogue apparaissant dans l’onglet
’Général’ , l’option ’Le fichier est en lecture seule’ peut être
sélectionnée. Cette option marquera le fichier correspondant comme
étant en lecture seule pour Code::Blocks, mais les attributs en lecture
et écriture du fichier original ne seront pas modifiés dans le système
de fichiers.
Si vous démarrez Code::Blocks en ligne de commande avec --personality=<profile>
la barre d’état affichera le profil utilisateur courant, sinon default sera affiché. Les
paramètres de Code::Blocks sont enregistrés dans le fichier de configuration corre-
spondant <personality>.conf.
Code::Blocks offre une gestion des projets très flexible et très compréhensible. Le texte
suivant ne montre que quelques aspects de la gestion de projets.
Code::Blocks 6
Code::Blocks V2.0.1 beta 1.1 Vue du projet
1.1 Vue du projet

Dans Code::Blocks, les sources et les paramètres d’un processus de génération sont stockés
dans un fichier projet <name>.cbp. Les sources en C/C++ et les fichiers d’en-têtes corre-
spondants (ou headers) sont les composants typiques d’un projet. La façon la plus simple
de créer un projet est de passer par la commande ’Fichier’ →’Projet’ et de choisir un
assistant. Vous pouvez alors ajouter des fichiers au projet via le menu de contexte ’Ajouter
des fichiers’ de la fenêtre de gestion.
Code::Blocks gère les fichiers de projets en catégories qui dépendent de l’extension des
fichiers. Les catégories suivantes sont prédéfinies :
Sources contient les fichiers sources dont l’extension est *.c;*.cpp;.
ASM Sources contient les fichiers sources dont l’extension est *.s;*.S;*.ss;*.asm.
Headers contient, entre autres, les fichiers dont l’extension est *.h;.
Ressources contient les fichiers pour paramétrer l’aspect des fenêtres des wxWidgets
avec les extensions *.res;*.xrc;. Ces types de fichiers sont affichés dans l’onglet
’Ressources’ de la fenêtre de Gestion.
Les paramètres des types et catégories de fichiers peuvent être ajustés via le menu de
contexte ’Arbre des projets’ →’Éditer les types et catégories de fichiers’ . Ici, vous pouvez
définir aussi des catégories personnalisées pour les extensions de votre choix. Par exem-
ple, si vous souhaitez lister des scripts d’édition de liens avec l’extension *.ld dans une
catégorie nommée Linkerscript, vous n’avez qu’à créer une nouvelle catégorie.
Note :
Si vous désactivez ’Arbre des projets’ →’Catégoriser par type de
fichiers’ dans le menu de contexte, l’affichage par catégories sera
masqué, et les fichiers seront listés comme ils sont stockés dans le
système de fichiers.
1.2 Notes pour les Projets

Dans Code::Blocks, des notes spécifiques peuvent être stockées dans un projet. Ces notes
peuvent contenir de brèves descriptions ou des points particuliers pour le projet corre-
spondant. En affichant ces informations à l’ouverture d’un projet, les autres utilisateurs
peuvent avoir un rapide aperçu de l’avancement du projet. L’affichage des notes peut être
validé ou invalidé via l’onglet Notes des Propriétés d’un projet.
1.3 Modèles de Projet

Code::Blocks est fourni avec tout un ensemble de modèles de projets qui sont affichés
quand on crée un nouveau projet. Cependant, vous pouvez aussi enregistrer des modèles
personnalisés pour y sauvegarder vos propres spécifications d’options de compilation, les
optimisations à utiliser, les options spécifiques aux machines etc. Ces modèles seront enreg-
istrés dans Documents and Settings\<user>\Application Data\codeblocks\UserTemplates
Code::Blocks 7
Code::Blocks V2.0.1 beta 1.4 Créer des Projets à partir de Cibles de Génération
sous Win 7 (ou un chemin équivalent du profil de l’utilisateur, adapté à chaque OS). Si les
modèles doivent pouvoir être ouverts par tous les utilisateurs, ils devront être copiés dans
un répertoire correspondant de l’installation de Code::Blocks. Ces modèles seront alors
affichés lors du démarrage suivant de Code::Blocks dans ’Nouveau’ →’Projet’ →’Modèles
utilisateur’ .
Note :
Les modèles disponibles dans l’assistant Projet peuvent être édités en
les sélectionnant via un clic droit.
1.4 Créer des Projets à partir de Cibles de Génération

Dans les projets, il est nécessaire d’avoir à disposition différentes variantes de projets. On
appelle ces variantes Cibles de Génération. Elles diffèrent par leurs options de compilation,
les informations de débogage et/ou le choix des fichiers. Une cible de génération peut aussi
être externalisée dans un projet séparé. Pour ce faire, cliquer sur ’Projet’ →’Propriétés’
puis sélectionner la variante dans l’onglet ’Générer les cibles’ et cliquer sur le bouton
’Créer un projet à partir d’une cible’ (voir Figure 1.2 à la page 8).
Figure 1.2: Cibles de Génération
1.5 Cibles Virtuelles

Les projets peuvent être également structurés dans Code::Blocks en ce qu’on appelle des
cibles virtuelles. Une structure fréquemment utilisée de projet consiste en deux cibles de
génération, la première cible ’Debug’ qui contient des informations pour le débogage et la
Code::Blocks 8
Code::Blocks V2.0.1 beta 1.6 Étapes Pré- et Post Génération
seconde cible ’Release’ sans ces informations. En ajoutant Cibles Virtuelles via ’Projet’
→’Propriétés’ →’Cibles de génération’ on peut combiner des cibles de génération indi-
viduelles. Par exemple, une Cible Virtuelle ’All’ peut créer les cibles Debug et Release
simultanément. Les cibles virtuelles sont affichées dans la barre de symboles du compila-
teur dans Générer les cibles.
1.6 Étapes Pré- et Post Génération

Dans Code::Blocks on peut effectuer des opérations complémentaires avant et après la
compilation d’un projet. Ces opérations sont appelées étapes de Pré génération ou Post
génération. Des Post générations typiques sont :
Création d’un format Intel Hexformat à partir un objet terminé
Manipulation d’objets par objcopy
Générer des fichiers de dump par objdump
Exemple
Créer le désassemblage d’un objet sous Windows. Le transfert vers un fichier nécessite
l’appel à cmd avec l’option /c.
cmd / c objdump =D name . e l f > name . d i s
Un autre exemple de Post génération peut être l’archivage d’un projet. Pour cela, créez
une cible de génération ’Archive’ et incluez les instructions suivantes dans l’étape de post
génération :
z i p = j 9 $ (PROJECT NAME) $ (TODAY) . z i p s r c h o b j $ (PROJECT NAME) . cbp
Avec cette commande, le projet actif et ses sources, en-têtes et objets seront compressés
en tant que fichier zip. En faisant ainsi, les variables intégrées $(PROJECT_NAME) et
$(TODAY), le nom du projet et la date courante seront extraites (voir section 3.2 à la
page 83). Après l’exécution de la cible ’Archive’, le fichier compressé sera stocké dans le
répertoire du projet.
Dans le répertoire share/codeblocks/scripts vous trouverez quelques exemples de
scripts. Vous pouvez ajouter un script via le menu ’Paramètres’ →’Édition de scripts’
et l’enregistrer dans un menu. Si vous exécutez par exemple le script make dist depuis le
menu, alors tous les fichiers appartenant à un projet seront compressés dans une archive
<project>.tar.gz.
1.7 Ajouter des Scripts à des Cibles de Génération

Code::Blocks offre la possibilité d’utiliser des actions de menus dans les scripts. Le script
représente un autre degré de liberté pour contrôler la génération de votre projet.
Note :
Un script peut également être inclus dans une Cible de Génération.
Code::Blocks 9
Code::Blocks V2.0.1 beta 1.8 Espace de travail et Dépendances de Projet
1.8 Espace de travail et Dépendances de Projet

Des projets multiples peuvent être ouverts dans Code::Blocks. En enregistrant les projets
ouverts via ’Fichier’ →’Enregistrer l’espace de travail’ vous pouvez les rassembler dans
un seul espace de travail sous <name>.workspace. Si vous ouvrez <name>.workspace
au démarrage suivant de Code::Blocks, tous les projets seront de nouveau affichés.
Les logiciels complexes sont un assemblage de composants qui sont gérés dans différents
projets Code::Blocks. De plus, lors de la génération de tels logiciels, il y a souvent des
dépendances entre ces projets.
Exemple
Un projet A contient des fonctions de base qui sont rendues disponibles aux autres projets
sous forme d’une librairie. Maintenant, si les sources de ce projet sont modifiées, alors la
librairie doit être re-générée. Afin de maintenir la consistance entre un projet B qui utilise
ces fonctions et le projet A qui les implémente, le projet B doit dépendre du projet A.
Les informations nécessaires aux dépendances des projets sont enregistrées dans l’espace
de travail adéquat, ainsi chaque projet peut être généré séparément. L’utilisation des
dépendances rend également possible le contrôle de l’ordre dans lequel sont générés les
projets. Les dépendances de projets peuvent être configurées en sélectionnant le menu
’Projet’ →’Propriétés’ puis en cliquant sur le bouton ’Dépendances du projet’.
1.9 Inclure des Fichiers en Assembleur

Dans la fenêtre Gestion d’une vue de projet, les fichiers en Assembleur sont affichés dans la
catégorie ASM Sources. L’utilisateur peut changer la liste des fichiers dans les catégories
(voir section 1.1 à la page 7). Un clic droit sur un des fichiers assembleur listés ouvrira un
menu de contexte. Sélectionner ’Propriétés’ pour ouvrir une nouvelle fenêtre. Sélectionnez
maintenant l’onglet ’Générer’ et activez les deux champs ’Compiler le fichier’ et ’Édition
de liens du fichier’. Sélectionnez ensuite l’onglet ’Avancé’ et exécutez les étapes suivantes
:
1. Configurer ’Variable de compilation’ à CC
2. Sélectionner le compilateur dans ’Pour ce compilateur’
3. Sélectionner ’Utiliser des commandes personnalisées pour générer ce fichier’
4. Dans la fenêtre, entrez :
$ c o m p i l e r $ o p t i o n s $ i n c l u d e s <a s o p t s > =c $ f i l e =o $ o b j e c t
Les variables de Code::Blocks sont identifiées par un $ (voir section 3.4 à la page 88).
Elles sont automatiquement configurées, ainsi vous n’avez à remplacer que l’option de
l’assembleur <asopt> par vos propres configurations.
Code::Blocks 10
Code::Blocks V2.0.1 beta 1.10 Éditeur et Outils
1.10 Éditeur et Outils

Cette section regroupe des fonctions internes à l’éditeur
1.10.1 Code par Défaut

Les règles de codage dans une compagnie imposent d’avoir un modèle standard. Avec
Code::Blocks, il est possible d’inclure un contenu prédéfini automatiquement en début de
fichier lors de la création d’une nouvelle source C/C++ ou d’en-têtes (headers). Le con-
tenu prédéfini est dénommé code par défaut. Cette configuration peut être sélectionnée
dans ’Paramètres’ →’Éditeur’ Code par Défaut. Si vous créez un nouveau fichier alors
une expansion des variables macro, notamment celles de ’Paramètres’ →’Variables Glob-
ales’ , est effectuée. Un nouveau fichier peut être créé via le menu ’Fichier’ →’Nouveau’
→’Fichier’ .
Exemple
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Project : $( project )
* Function :
***************************************************************
* $ Author : mario $
* $Name : $
***************************************************************
*
* Copyright 2007 by company name
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1.10.2 Abréviations
Pas mal de frappes au clavier peuvent être économisées dans Code::Blocks en définissant
des abréviations. Ceci peut s’obtenir en sélectionnant ’Paramètres’ →’Éditeur’ et en
définissant les abréviations par un nom <name>, qui peut alors être appelé par un rac-
courci clavier Ctrl-J (voir Figure 1.3 à la page 12).
On peut également les paramétrer en incluant des variables $(NAME) dans les abréviations.
#i f n d e f $ ( Guard token )
#define $ ( Guard token )
#endif // $ ( Guard token )
Quand on utilise l’abréviation <name> dans un texte source et qu’on utilise Ctrl-J, le
contenu de la variable est récupéré puis inclus.
1.10.3 Personnalités
Les configurations de Code::Blocks sont enregistrées en tant que données d’application
dans un fichier dénommé <user>.conf dans le répertoire de codeblocks. Ce fichier de
configuration contient des informations telles que les derniers projets ouverts, le paramétrage
Code::Blocks 11
Figure 1.3: Définition des abréviations
de l’éditeur, l’affichage des barres de symboles etc. Par défaut, la personnalité ’default’ est
utilisée et sa configuration sauvegardée dans un fichier default.conf. Si Code::Blocks est
lancé en ligne de commande avec le paramètre --personality=myuser, le paramétrage
sera enregistré dans un fichier myuser.conf. Si le profil n’existe pas déjà, il sera au-
tomatiquement créé. Cette procédure rend possible la création de différents profils pour
différentes étapes de travail. Si vous lancez Code::Blocks en ligne de commande avec le
paramètre additionnel --personality=ask, une boı̂te de sélection sera affichée avec tous
les profils disponibles.
Note :
Le nom du profil/personnalité courant est affiché dans le coin à droite
de la barre d’état.
1.10.4 Fichiers de Configuration

Les paramètres de Code::Blocks sont enregistrés dans le fichier de profil default.conf
dans le répertoire codeblocks de votre Application Data. Quand vous utilisez des per-
sonnalités (ou profils) (voir sous-section 1.10.3 à la page 11), les détails de configuration
sont enregistrés dans un fichier <personality>.conf.
L’outil cb share conf, qu’on trouve dans le répertoire d’installation de Code::Blocks, est
utilisé pour gérer et enregistrer ces paramétrages.
Si vous souhaitez définir des paramètres standard pour plusieurs utilisateurs de l’ordinateur,
le fichier de configuration default.conf doit être enregistré dans le répertoire \Documents
and Settings\Default User\Application Data\codeblocks. Lors du premier démarrage,
Code::Blocks 12
Code::Blocks copiera les valeurs par défaut depuis ’Default User’ vers le répertoire ”Ap-
plication data” de l’utilisateur courant.
Pour créer une version portable de Code::Blocks sur clé USB, procédez comme suit. Copiez
le répertoire d’installation de Code::Blocks vers la clé USB et stockez le fichier de con-
figuration default.conf dans ce répertoire. Cette configuration servira de paramétrage
global. Faites attention au fait que ce fichier soit accessible en écriture, sinon les change-
ments de configuration ne pourront y être enregistrés.
1.10.5 Navigation et Recherche

Dans Code::Blocks il y a plusieurs façons de naviguer rapidement entre les fichiers et les
fonctions. Une procédure typique est la configuration de marques de recherche. Via le
raccourci clavier Ctrl-B une marque est posée ou supprimée dans un fichier source. Via
Alt-PgUp vous pouvez aller à la marque précédente, et via Alt-PgDn vous pouvez aller à
la marque suivante.
Si vous sélectionnez l’espace de travail ou un projet particulier de l’espace de travail
dans la vue du projet vous pouvez rechercher un fichier dans le projet. Sélectionnez tout
simplement ’Rechercher le fichier’ depuis le menu de contexte, puis tapez le nom du fichier
et le fichier sera sélectionné. Si vous tapez sur la touche Entrée, ce fichier sera ouvert dans
l’éditeur (voir Figure 1.4 à la page 13).
Figure 1.4: Recherche de fichiers
Dans Code::Blocks vous pouvez facilement naviguer entre les En-têtes/Sources en :

1. Positionnant le curseur à l’endroit où le fichier d’en-tête (header) est inclus puis
ouvrir ce fichier via le menu de contexte ’Ouvrir le fichier inclus’ (voir Figure 1.5 à
la page 14)
2. Basculer du fichier d’en-tête au fichier source via le menu de contexte ’Basculer
en-tête/source’
3. Sélectionner par exemple un define dans l’éditeur et choisir ’Trouver la déclaration’
depuis le menu de contexte pour ouvrir le fichier contenant cette déclaration.
Code::Blocks offre plusieurs possibilités de recherches dans un fichier ou un répertoire.
La boı̂te de dialogue de recherche s’ouvre par ’Chercher’ →’Rechercher’ (Ctrl-F) ou
’Rechercher dans les fichiers’ (Ctrl-Shift-F).
Code::Blocks 13
Figure 1.5: Ouverture d’un fichier d’en-têtes
Alt-G et Ctrl-Alt-G sont d’autres fonctions utiles. Le dialogue qui s’ouvrira en utilisant
ces raccourcis vous permet de choisir des fichiers/fonctions et aller vous positionner à
l’implémentation de la fonction sélectionnée (voir Figure 1.6 à la page 14) ou bien ouvrir
le fichier sélectionné dans l’éditeur. Vous pouvez utiliser dans le dialogue des jokers comme
* ou ? etc. pour y obtenir une recherche incrémentale.
Figure 1.6: Recherche de fonctions
Note :
Avec le raccourci Ctrl-PgUp vous pouvez aller à la fonction
précédente, et via Ctrl-PgDn vous pouvez aller à la fonction suivante.
Dans l’éditeur, vous pouvez ouvrir un nouveau dialogue Ouvrir des fichiers Ctrl-Tab et
vous pouvez passer de l’un à l’autre via la liste affichée. Si vous appuyez sur la touche
Ctrl, alors un fichier peut être sélectionné de différentes façons :
1. Si vous sélectionnez une entrée avec le bouton gauche de la souris, le fichier sélectionné
sera ouvert.
2. Si vous appuyez sur la touche Tab vous passez de l’une à l’autre des entrées listées.
En relâchant la touche Ctrl le fichier sélectionné sera ouvert.
Code::Blocks 14
3. Si vous déplacez la souris au-dessus des entrées listées, alors la sélection courante
sera surlignée. En relâchant la touche Ctrl le fichier sélectionné sera ouvert..
4. Si le pointeur de souris est en dehors de la sélection surlignée, vous pouvez utiliser
la molette de la souris pour basculer entre les entrées. En relâchant la touche Ctrl
le fichier sélectionné sera ouvert.
Une façon commune de développer du logiciel est de jongler avec un ensemble de fonctions
implémentées dans différents fichiers. L’extension ”Browse Tracker” vous aidera à résoudre
cette tâche en vous montrant dans quel ordre ont été sélectionnés les fichiers. Vous pouvez
alors naviguer aisément entre les appels de fonctions (voir section 2.4 à la page 44).
L’affichage des numéros de lignes dans Code::Blocks peut s’activer via ’Paramètres’ →’Éditeur’
→’Paramètres généraux’ à l’aide du champ ’Afficher les numéros de ligne’. Le raccourci
Ctrl-G ou la commande de menu ’Rechercher’ →’Aller à la ligne’ vous aidera à atteindre
la ligne désirée.
Note :
Si vous maintenez la touche Ctrl enfoncée en sélectionnant du texte
dans l’éditeur de Code::Blocks vous pouvez lancer une recherche In-
ternet, notamment avec Google, via le menu de contexte.
1.10.6 Vue des Symboles

La fenêtre Gestion de Code::Blocks offre une vue arborescente des symboles des sources
en C/C++ pour naviguer dans les fonctions et les variables. Dans ce type de vue, vous
pouvez travailler sur le fichier courant, le projet courant ou tout l’espace de travail.
Note :
Entrer un terme à chercher ou des noms de symboles dans le masque
d’entrée ’Rechercher’ du navigateur de Symboles permet d’obtenir
une vue filtrée des symboles si concordance il y a.
Les catégories suivantes existent pour les symboles :

Fonctions Globales Liste l’implémentation des fonctions globales.
typedefs globales Liste l’utilisation des définitions typedef.
Variables globales Affiche les symboles de variables globales.
Symboles du pré-processeur Liste les directives du pré-processeur créées par #define.
Macros globales Liste les macros des directives du pré-processeur
Code::Blocks 15
Figure 1.7: Vue des symboles
Les structures et classes sont affichées par le menu ’arbre du bas’ et l’ordre de tri peut être
modifié via le menu de contexte. Si une catégorie est sélectionnée à la souris, les symboles
trouvés seront affichés dans la partie basse de la fenêtre (voir Figure 1.7 à la page 16).
Double-cliquer sur un symbole ouvrira le fichier où il est défini ou bien la fonction où elle
est implémentée, puis on se positionnera sur la ligne correspondante. Un rafraı̂chissement
automatique du navigateur de symboles, sans avoir à sauvegarder de fichier, peut être
activé par le menu ’Paramètres’ →’Éditeur’ →’Code Complétion’ (voir Figure 1.8 à la
page 17). Les performances de Code::Blocks seront affectées dans les projets comportant
de nombreux symboles.
Code::Blocks 16
Figure 1.8: Activation de l’analyse en temps réel
Note :
Dans l’éditeur, une liste de classes peut être affichée via les menus de
contexte ’Insérer méthode de classe’ ou ’Toutes méthodes de classes
sans implémentation’ .
1.10.7 Inclure des Fichiers d’Aide Externes

Code::Blocks est seulement fourni avec son propre fichier d’aide : normalement, les développeurs
ont besoin de bien plus d’aides et de références pour les langages, les librairies, les pro-
tocoles, les formats de fichiers et ainsi de suite. Le plugin help rend accessible toute la
documentation nécessaire depuis Code::Blocks lui-même. Virtuellement, tout document
peut être interprété par le système d’aide de Code::Blocks, depuis que le ”plugin help” a
la possibilité, si besoin, de lancer des programmes externes pour visualiser les documents
ajoutés.
Une fois qu’a été ajouté un nouveau fichier ou document d’aide, une nouvelle entrée dans
le menu ”Aide” est disponible afin de pouvoir l’ouvrir.
L’environnement de développement Code::Blocks supporte l’inclusion de fichiers d’aide
externes via le menu ’Paramètres’ →’Environnement’ . Insérez le manuel de votre choix
(au format chm par ex., voir ci-dessous) dans la sélection ’Fichiers d’aide’ , sélectionnez
’Ceci est le fichier d’Aide par défaut’ (voir Figure 1.9 à la page 18). L’entrée $(keyword)
est un paramètre de substitution pour une sélection particulière dans votre éditeur. Vous
pouvez alors sélectionner une fonction dans un fichier ouvert de Code::Blocks par un
simple clic, et la documentation correspondante s’affichera lorsque vous appuierez sur la
touche F1.
Si vous avez inclus plusieurs fichiers d’aide, vous pouvez choisir un terme particulier dans
l’éditeur, puis choisir le fichier d’aide adéquat dans le menu de contexte ’Chercher dans’
pour que Code::Blocks y fasse la recherche.
Dans Code::Blocks vous pouvez également ajouter un support de pages ”man”. Ajoutez
seulement une entrée ’man’ et spécifiez les chemins comme suit (NdT ici pour Linux!).
Code::Blocks 17
Figure 1.9: Configuration des fichiers d’aide
man : / u s r / s h a r e /man
Sous Linux, les pages man sont habituellement installées de toute façon. Sous Windows
vous pourriez vouloir les télécharger, par ex. depuis ici : http://www.win.tue.nl/~aeb/
linux/man
Options d’Aide
Vous pouvez demander à Code::Blocks d’utiliser un fichier particulier comme fichier
d’aide par défaut, en cochant la case ”Ceci est le fichier d’aide par défaut”. Ainsi,
ce fichier sera affiché dès lors que vous appuierez sur la touche ’F1’. De plus, si
vous écrivez le mot $(keyword) en tant que mot clé par défaut (voir plus loin), on
cherchera ces mots clés dans ce fichier (le mot sélectionné ou le mot sous le curseur
du fichier source courant) et les correspondances seront affichées, si elles existent.
Vous pouvez demander à Code::Blocks d’ouvrir un fichier d’aide sur un sujet de
votre choix, en écrivant le mot clé correspondant dans la boı̂te de texte ”Valeur
du mot clé par défaut”. Si le fichier d’aide est celui par défaut et que vous utilisez
$(keyword) comme mot clé par défaut, l’éditeur utilisera le mot sous le curseur
(ou celui sélectionné) dans le fichier d’aide actuellement ouvert comme mot clé, en
ouvrant le fichier d’aide par défaut sur le sujet adéquat. Ceci ne sera toutefois vrai
que sur le fichier d’aide par défaut : on ne cherchera pas de cette façon dans les autres
fichiers d’aide. Par exemple, si vous avez une référence de langage comme fichier
d’aide par défaut et que vous ajoutez un fichier d’aide sur une librairie standard, vous
obtiendrez l’explication du mot clé du langage en appuyant sur la touche ’F1’, mais
vous n’aurez pas les fonctions de librairie expliquées de cette façon. Inversement, en
configurant le fichier de la librairie par défaut, via la touche F1 vous perdrez cette
fonctionnalité pour les mots clés de langage.
Si votre fichier d’aide est un fichier HTML, vous pouvez demander à Code::Blocks
Code::Blocks 18
de l’ouvrir avec le visualiseur de fichiers HTML intégré, en cochant l’option corre-

spondante.
Code::Blocks fourni un ’Visualiseur HTML intégré’, qui peut être utilisé pour afficher un
simple fichier html et y rechercher des mots clés. Configurez simplement le chemin du
fichier html qui doit être analysé et cochez la case ’Ouvrir ce fichier avec le visualiseur
d’aide intégré’ via le menu ’Paramètres’ →’Environnement’ →’Fichiers d’aide’ .
Figure 1.10: Visualiseur HTML intégré
Note :
Si vous sélectionnez un fichier html par double-clic dans l’explorateur
(voir section 2.8 à la page 50) alors le visualiseur html intégré sera
démarré, du moins si aucune association vers les fichiers html n’est
faite par le gestionnaire d’extensions de fichiers.
Fichiers CHM
Vous pouvez trouver des fichiers d’aide c++ chm sur le web. Ajoutez-les tout simplement
dans la boı̂te de dialogue.
Sous Linux vous avez à installer un visualiseur de fichiers chm pour pouvoir afficher ces
fichiers chm. Il y en a plusieurs comme gnochm, kchmviewer, xchm et ainsi de suite.
1.10.8 Inclure des outils externes

L’inclusion d’outils externes dans Code::Blocks est faisable via ’Outils’ →’Configurer les
outils’ →’Ajouter’ . Les variables internes (voir section 3.2 à la page 83) peuvent aussi
être utilisées comme paramètres des outils. D’autre part, il y a plusieurs sortes d’options
de lancement pour démarrer des applications externes. En fonction des options, les ap-
plications externes peuvent s’arrêter quand on quitte Code::Blocks. Si les applications
Code::Blocks 19
Code::Blocks V2.0.1 beta 1.11 Astuces pour travailler avec Code::Blocks
doivent rester ouvertes après qu’on ait quitté Code::Blocks, l’option ’Lancer l’outil visible
en mode détaché’ doit être cochée.
1.11 Astuces pour travailler avec Code::Blocks

Dans ce chapitre nous présenterons quelques paramétrages utiles dans Code::Blocks.
1.11.1 Recherche de Modifications

Code::Blocks fourni une fonctionnalité pour pister les modifications effectuées dans un
fichier source et affiche une barre dans la marge là où ont eût lieu les changements. Les
modifications sont marquées par une barre de changements jaune alors que celles qui ont
déjà été enregistrées sont marquées par une barre de changements verte (voir Figure 1.11
à la page 20). Vous pouvez naviguer dans vos changements à l’aide du menu ’Rechercher’
→’Aller à la ligne changée suivante’ ou encore ’Rechercher’ →’Aller à la ligne changée
précédente’ . La même fonctionnalité est accessible via les raccourcis clavier Ctrl-F3 et
Ctrl-Shift-F3.
Figure 1.11: Recherche de modifications
Cette fonctionnalité peut être activée ou désactivée via la case à cocher ’Utiliser la barre
de changements’ dans le menu ’Paramètres’ →’Éditeur’ →’Marges et tirets’ .
Note :
Si un fichier modifié est fermé, alors l’historique des changements tels
que défaire/refaire ainsi que la barre de changements sont perdus. À
l’aide du menu ’Édition’ →’Effacer l’historique des changements’ ou
le menu de contexte correspondant vous pouvez effacer cet historique
même si le fichier reste ouvert.
1.11.2 Échange de données avec d’autres applications

Les échanges de données entre Code::Blocks et d’autres applications sont possibles. Pour
cela on utilise, avec Windows, le processus de communication inter processus DDE (Dy-
namic Data Exchange) et, avec les autres systèmes d’exploitation, une communication
basée sur le protocole TCP.
Avec cette interface, différentes commandes peuvent être envoyées vers une instance de
Code::Blocks en suivant la syntaxe suivante.
Code::Blocks 20
[<command>(”<parameter>” ) ]
Les commandes suivantes sont actuellement disponibles :

Open La commande
[ Open ( ”d : \ temp\ t e s t . t x t ” ) ]
utilise un paramètre, dans notre cas c’est le nom d’un fichier avec
son chemin en absolu, et il s’ouvre dans une instance existante de
Code::Blocks ou bien, si nécessaire, une première instance démarre.
OpenLine Cette commande ouvre un fichier dans une instance de Code::Blocks
et se positionne sur la ligne dont le numéro est entré. Le numéro de
ligne est spécifié par : ligne .
[ OpenLine ( ”d : \ temp\ t e s t . t x t : 1 0 ” ) ]
Raise Donne le ”focus” à l’instance de Code::Blocks. Aucun paramètre ne

doit être entré.
1.11.3 Configurer les variables d’environnement

La configuration d’un système d’exploitation se fait par ce qu’on appelle les variables
d’environnement. Par exemple, la variable d’environnement PATH contient le chemin
d’un compilateur installé. Le système d’exploitation analysera cette variable dans l’ordre
d’écriture, c’est à dire que les entrées de la fin seront utilisées en dernier dans les recherches.
Si plusieurs versions de compilateur ou d’autres applications sont installées, les situations
suivantes peuvent se produire :
On appelle une version incorrecte d’un logiciel
Les logiciels installés s’appellent entre eux
Ainsi, on peut tomber sur le cas où différentes versions d’un compilateur ou d’un autre
outil sont obligatoires pour différents projets. Lorsque cela arrive, une première solution
est de changer les variables d’environnement dans le système d’exploitation pour chaque
projet. Toutefois cette procédure est sujette à erreur et manque de flexibilité. Pour ce faire,
Code::Blocks offre une solution élégante. Différentes configurations de variables peuvent
être créées pour un usage uniquement en interne à Code::Blocks. De plus, vous pouvez
passer de l’une à l’autre de ces configurations. La Figure 1.12 à la page 22 montre la
boı̂te de dialogue que vous obtenez via ’Variables d’Environnement’ dans ’Paramètres’
→’Environnement’ . On crée une configuration à l’aide du bouton ’Créer’.
L’accès et l’étendue des variables d’environnement ainsi créées sont limités à Code::Blocks.
Vous pouvez étendre ces variables d’environnement comme toutes les autres variables dans
Code::Blocks à l’aide de $(NAME).
Note :
La configuration d’une variable d’environnement pour chaque pro-
jet peut être sélectionnée dans le menu de contexte ’Propriétés’ de
l’onglet ’Options EnvVars’.
Code::Blocks 21
Figure 1.12: Variables d’environnement
Exemple
Vous pouvez écrire dans un fichier <project>.env l’environnement utilisé dans une étape
de post génération (voir section 1.6 à la page 9) puis l’archiver dans votre projet.
cmd / c echo \%PATH\% > p r o j e c t . env
ou sous Linux
echo \$PATH > p r o j e c t . env
1.11.4 Basculer entre diverses dispositions

En fonction des tâches à effectuer, il peut être utile d’avoir plusieurs configurations ou dis-
positions (ou présentations) différentes de Code::Blocks et de les sauvegarder. Par défaut,
le paramétrage (notamment afficher/masquer les barres d’outils, aspect, etc.) est enreg-
istré dans le fichier de configuration default.conf. En utilisant l’option en ligne de
commande --personality=ask au démarrage de Code::Blocks, on peut choisir parmi
plusieurs possibilités de paramétrages. En dehors de ces paramétrages globaux, il peut se
produire une situation où vous souhaitez basculer entre différentes vues de fenêtres ou de
barres de symboles pendant une session. L’édition de fichier et le débogage de projets sont
deux exemples typiques de telles situations. Code::Blocks offre un mécanisme pour enreg-
istrer et sélectionner différentes dispositions afin d’éviter à l’utilisateur d’avoir à fermer et
ouvrir manuellement et fréquemment des fenêtres et des barres de symboles. Pour enreg-
istrer une disposition, sélectionnez le menu ’Vue’ →’Disposition’ →’Enregistrer la dispo-
sition actuelle’ et entrez un nom dans <nom>. La commande ’Paramètres’ →’Éditeur’
→’Raccourcis clavier’ →’Vue’ →’Dispositions’ →’<name>’ permet de définir un rac-
courci clavier pour ce processus. Il est ainsi possible de basculer entre les diverses dispo-
sitions simplement en utilisant ces raccourcis clavier.
Code::Blocks 22
Note :
Autre exemple : éditer un fichier en mode plein écran sans barre de
symboles. Vous pouvez créer une disposition comme ’Plein Ecran’ et
lui assigner un raccourci spécifique.
1.11.5 Basculer entre projets

Si plusieurs projets ou fichiers sont ouverts en même temps, l’utilisateur a besoin d’un
moyen pour passer rapidement de l’un à l’autre. Code::Blocks possède plusieurs raccourcis
pour ce faire.
Alt-F5 Active le projet précédent de la vue des projets.
Alt-F6 Active le projet suivant de la vue des projets.
F11 Dans l’éditeur, bascule entre un fichier source <name>.cpp et le fichier d’en-tête
(header) correspondant <name>.h
1.11.6 Configurations étendue des compilateurs

Lors de la génération d’un projet, les messages du compilateur sont affichés dans l’onglet
Messages de génération. Si vous souhaitez recevoir des informations détaillées, l’affichage
peut être étendu. Pour cela, cliquez sur ’Paramètres’ →’Compilateur et débogueur’ puis
sélectionnez l’onglet ’Autres options’ dans le menu déroulant.
Figure 1.13: Configurer des informations détaillées
Code::Blocks 23
Assurez-vous que le compilateur soit correctement sélectionné. L’option ’Ligne de com-

mande complète’ des Avertissements du compilateur permet de sortir des informations
détaillées. De plus, ces sorties peuvent être redirigées vers un fichier HTML. Pour cela,
sélectionnez ’Enregistrer le journal de génération dans un fichier HTML en fin de génération’.
D’autre part, Code::Blocks peut afficher une barre d’avancement du processus de génération
dans la fenêtre de génération qui peut être activée en cochant ’Afficher la barre de pro-
gression de génération’.
1.11.7 Zoomer dans l’éditeur

Code::Blocks possède un éditeur très puissant. Cet éditeur vous permet de changer la
taille des caractères du texte affiché des fichiers ouverts. Si vous avez une souris avec une
molette, vous n’avez qu’à appuyer sur la touche Ctrl tout en tournant la molette dans un
sens ou l’autre pour agrandir ou réduire la taille du texte.
Note :
Avec le raccourci Ctrl-Numepad-/ ou à l’aide du menu ’Édition’
→’Commandes spéciales’ →’Zoom’ →’Remise à 0’ vous restaurez
la taille originale du texte courant.
1.11.8 Mode de Repliement

Quand on édite des fichiers de texte, notamment des *.txt, dans Code::Blocks, il peut
être utile d’avoir le texte replié, ce qui signifie que les lignes longues seront affichées
sur plusieurs lignes à l’écran afin qu’elles puissent être correctement éditées. La fonc-
tion ’Repliement’ peut être activée dans ’Paramètres’ →’Éditeur’ →’Autres Options’
ou en cochant la case ’Activer le repliement’ . Les touches ”Home” et ”Fin” position-
nent respectivement le curseur en début et en fin de ligne repliée. Quand on choisit
’Paramètres’ →’Éditeur’ →’Autres Options’ et ’La touche Home déplace toujours le
curseur en première colonne’ , le curseur sera positionné respectivement en début ou en
fin de ligne si on appuie sur la touche ”Home” ou ”Fin”. Si on désire placer le curseur au
début de la première ligne du paragraphe en cours, il vous faut utiliser la combinaison de
touches ’Alt-Home’ . La même chose de façon analogue pour ’Alt-Fin’ pour positionner
le curseur en fin de la dernière ligne du paragraphe courant.
1.11.9 Sélection de modes dans l’éditeur

Code::Blocks supporte différents modes de sélection pour le couper-coller des chaı̂nes de
caractères.
1. Un texte de l’éditeur actif peut être sélectionné avec le bouton gauche de la souris,
puis on relâche ce bouton. L’utilisateur peut se déplacer de haut en bas avec la
molette de la souris. Si on appuie sur le bouton du milieu, le texte précédemment
sélectionné sera inséré. Cet effet est disponible au niveau d’un fichier et peut être
vu comme un presse-papier de fichier.
2. Appuyer sur la touche ’ALT’ active ce qu’on appelle la sélection en mode bloc et
un rectangle de sélection s’affiche à l’aide du bouton gauche de la souris. Lorsqu’on
Code::Blocks 24
relâche la touche Alt cette sélection peut être copiée ou collée. Cette option est
utile si vous voulez sélectionner des colonnes, notamment dans un tableau et en
copier-coller le contenu.
3. Dans le menu ’Paramètres’ →’Éditeur’ →’Marges et tirets’ on peut activer ce
qu’on appelle des ’Espaces Virtuels’ . Ceci active la possibilité d’avoir une sélection
en mode bloc qui peut commencer ou se terminer par une ligne vide.
4. Dans le menu ’Paramètres’ →’Éditeur’ →’Marges et tirets’ on peut activer le
’Sélections Multiples’ . En maintenant enfoncée la touche Ctrl l’utilisateur peut
sélectionner diverses lignes dans l’éditeur actif avec le bouton gauche de la souris.
Les sélections sont ajoutées dans le presse-papier à l’aide des raccourcis Ctrl-C ou
Ctrl-X. Ctrl-V en insèrera le contenu à la position courante du curseur. Une option
complémentaire dénommée ’Active l’entrée clavier (et la suppression)’ peut être
activée pour les sélections multiples. Cette option est utile si vous voulez ajouter
des directives de pré-processeur comme #ifdef sur plusieurs lignes de code source
ou si vous voulez superposer ou remplacer du texte en plusieurs endroits.
Note :
La plupart des gestionnaires de fenêtres de Linux utilisent ALT-
ClicGauche-Déplacer pour déplacer une fenêtre, aussi vous devrez
désactiver cette fonctionnalité pour pouvoir sélectionner en mode
bloc.
1.11.10 Repliement de code

Code::Blocks supporte ce qu’on appelle le repliement de code. Avec cette fonctionnalité
vous pouvez replier notamment les fonctions dans l’éditeur de Code::Blocks. Un point
de repliement est marqué dans la marge gauche de l’éditeur par un signe moins. Dans la
marge, le début et la fin d’un point de repliement sont visibles à l’aide d’une ligne verticale.
Si vous cliquez sur le signe moins avec le bouton gauche de la souris, la portion de code
sera repliée ou dépliée. Via le menu ’Édition’ →’Repliement’ vous pouvez sélectionner le
repliement. Dans l’éditeur, un code replié est vu comme une ligne horizontale continue.
Note :
Le style de repliement et la profondeur limite du repliement peuvent
se configurer dans le menu ’Paramètres’ →’Éditeur’ →’Repliement’ .
Code::Blocks fournit aussi la fonctionnalité de repliement pour les directives du pré-

processeur. Pour l’activer, sélectionnez ’Replier les commandes du pré-processeur’ dans
l’entrée Repliement de ’Paramètres’ →’Éditeur’ .
Une autre façon de faire est de définir des points de repliement utilisateurs. Le point de
départ du repliement s’entre comme un commentaire suivi d’une parenthèse ouvrante et
la fin comme un commentaire suivi d’une parenthèse fermante.
//{
code avec repliement défini par l’utilisateur
//}
Code::Blocks 25
1.11.11 Auto complétion

Lorsque vous ouvrez un projet dans Code::Blocks les ’Répertoires de recherche’ de votre
compilateur et de votre projet, les fichiers sources et d’en-têtes de votre projet sont
analysés. De plus les mots clés de l’analyseur syntaxique correspondant sont analysés
également. Les informations issues de l’analyse sont alors utilisées pour la fonctionnalité
d’auto complétion dans Code::Blocks. Vérifiez s’il vous plait que cette fonctionnalité est
bien activée dans l’éditeur. L’auto complétion est accessible au travers du raccourci Ctrl-
Espace. Via le menu ’Paramètres’ →’Éditeur’ →’Colorisation syntaxique’ vous pouvez
ajouter des mots clés définis par l’utilisateur à votre analyseur syntaxique.
1.11.12 Recherche de fichiers cassés

Lorsqu’un fichier est supprimé du disque, mais est toujours inclus dans un fichier projet
<project>.cbp, alors un ’fichier cassé’ sera affiché avec un symbole ”cassé” dans la vue
du projet. Vous devriez utiliser ’Enlever ce fichier du projet’ plutôt que de supprimer le
fichier.
Dans de gros projets, avec de nombreux sous-répertoires, la recherche de fichiers cassés
peut être une grande consommatrice de temps. Avec l’extension ThreadSearch (voir sec-
tion 2.18 à la page 75) Code::Blocks apporte une solution simple à ce problème. Si vous
entrez une expression de recherche dans ThreadSearch et sélectionnez l’option ’Fichiers
du projet’ ou ’Fichiers de l’espace de travail’ , alors ThreadSearch analysera tous les
fichiers qui sont inclus dans le projet ou l’espace de travail. Si un fichier cassé est trouvé,
ThreadSearch génèrera une erreur sur le fichier absent.
1.11.13 Inclure des librairies

Dans les options de génération d’un projet, vous pouvez ajouter les librairies utilisées via
le bouton ’Ajouter’ dans l’entrée ’Librairies à lier’ des ’Options de l’éditeur de liens’. Ce
faisant, vous pouvez soit utiliser le chemin absolu de la librairie ou seulement donner son
nom sans le préfixe lib ni l’extension du fichier.
Exemple
Pour une librairie nommée <path>\libs\lib<name>.a, écrire seulement <name>. L’éditeur
de liens avec les chemins de recherche correspondants inclura alors correctement les li-
brairies.
Note :
Une autre façon d’inclure des librairies est documentée dans la sec-
tion 2.12 à la page 59.
1.11.14 Ordre d’édition de liens des fichiers objets

Lors de la compilation, les fichiers objets name.o sont créés à partir des sources name.c/cpp.
L’éditeur de liens assemble les fichiers objets individuels pour en faire une application
name.exe ou sur d’autre systèmes name.elf. Dans certains cas, il peut être préférable
Code::Blocks 26
Code::Blocks V2.0.1 beta 1.12 Code::Blocks en ligne de commande
de prédéfinir l’ordre dans lequel seront liés les fichiers objets. Vous pouvez obtenir cela
dans Code::Blocks en assignant des priorités. Dans le menu de contexte ’Propriétés’ , vous
pouvez définir les priorités d’un fichier dans l’onglet Générer. Une priorité faible fera que
le fichier sera lié plus tôt.
1.11.15 Sauvegarde automatique

Code::Blocks offre la possibilité d’enregistrer automatiquement les projets et les fichiers
sources, ou encore de créer des copies de sauvegarde. Cette fonctionnalité peut être activée
dans le menu ’Paramètres’ →’Environnement’ →’Sauvegarde-auto’ . Ce faisant, ’Enreg-
istrer dans un fichier .save’ doit être spécifié comme méthode de création de copie de
sauvegarde.
1.11.16 Configuration des extensions de fichiers

Dans Code::Blocks, vous pouvez choisir entre plusieurs méthodes de traitement des exten-
sions de fichiers. La boı̂te de dialogue de configuration s’ouvre par ’Paramètres’ →’Gestion
des extensions de fichiers’ . Vous pouvez alors soit utiliser les applications assignées par
Windows pour chaque extension de fichier (l’ouvrir avec l’application associée), ou changer
la configuration pour chaque extension de telle façon que ce soit un programme défini par
l’utilisateur qui soit lancé (lancer un programme externe), ou que ce soit Code::Blocks qui
ouvre le fichier dans son éditeur (l’ouvrir dans l’éditeur de Code::Blocks).
Note :
Si un programme utilisateur est associé à une certaine extension
de fichier, la configuration ’Désactiver Code::Blocks quand un pro-
gramme externe est lancé’ devrait être désactivée, sinon Code::Blocks
sera fermé dès qu’un fichier qui possède cette extension est ouvert.
1.12 Code::Blocks en ligne de commande

L’Environnement de Développement Intégré (IDE) Code::Blocks peut être exécuté depuis
une ligne de commande sans interface graphique. Dans ce cas, plusieurs options sont
disponibles pour contrôler le processus de génération d’un projet. Comme Code::Blocks
peut être piloté par des ”scripts”, la création d’exécutables peut être intégrée dans vos
propres processus de travail.
c o d e b l o c k s . exe /na /nd ==no=s p l a s h = s c r e e n == b u i l d <name>. cbp == t a r g e t= ’ R e l e a s e ’
<filename> Spécifie le nom du fichier de projet *.cbp ou le nom de l’espace de tra-

vail *.workspace. Par exemple, <filename> peut être project.cbp.
Placez cet argument en fin de ligne de commande, juste avant la redi-
rection de la sortie, s’il y en a une.
--file=<filename>[:ligne]
Ouvrir un fichier dans Code::Blocks et, en option, se positionner sur
une ligne particulière.
Code::Blocks 27
Code::Blocks V2.0.1 beta 1.13 Raccourcis Clavier
/h, --help Affiche un message d’aide concernant les arguments en ligne de com-
mande.
/na, --no-check-associations
Ne faire aucun contrôle d’association de fichiers (Windows seulement).
/nd, --no-dde Ne pas lancer le serveur DDE (Windows seulement).
/ni, --no-ipc Ne pas lancer le serveur IPC (Linux et Mac seulement).
/ns, --no-splash-screen
Ne pas afficher l’écran de démarrage pendant le chargement de l’application.
/d, --debug-log
Afficher le journal de débogage de l’application.
--prefix=<str>
Configure le préfixe du répertoire de données partagées.
/p, --personality=<str>, --profile=<str>
Configure le profil (ou personnalité) à utiliser. Vous pouvez utiliser le
paramètre ask pour afficher la liste de tous les profils disponibles.
--rebuild Nettoie et génère le projet ou l’espace de travail.
--build Génère le projet ou l’espace de travail.
--target=<str>
Configure la cible de génération. Par exemple --target=’Release’.
--no-batch-window-close
Garde la fenêtre batch de journalisation visible après que la génération
par batch soit terminée.
--batch-build-notify
Affiche un message une fois que la génération batch est terminée.
--safe-mode Désactive toutes les extensions (plugins) au démarrage.
> <build log file>
Placé en toute dernière position d’une ligne de commande, ceci permet
à l’utilisateur de rediriger la sortie standard vers un fichier log. Ceci
n’est pas à proprement parler une option de codeblocks, mais seulement
une redirection standard des sorties des shells DOS/*nix.
1.13 Raccourcis Clavier

Cette section décrit les raccourcis clavier qui sont ou peuvent être utilisés dans Code::Blocks.
1.13.1 Introduction
Ce plugin peut être utilisé pour ajouter un ou plusieurs raccourcis clavier aux menus.
Même si une IDE comme Code::Blocks est surtout pilotée à la souris, les raccourcis claviers
sont néanmoins un moyen très pratique pour accélérer et simplifier le travail. Les tableaux
ci-dessous regroupent quelques-uns des raccourcis claviers disponibles.
Code::Blocks 28
1.13.2 Fonctionnalités
Inclue un panneau de configuration et un système complet pour visualiser/supprimer/a-
jouter/éditer des commandes en raccourcis clavier.
Supporte plusieurs profils de raccourcis clavier et un système complet de chargement/en-
registrement est présent.
Permet à l’utilisateur de personnaliser toutes les commandes de menus désirées, et définir
des raccourcis clavier pour chacune des commandes.
1.13.3 Utilisation
La page de configuration du plugin est accessible via le menu ’Paramètres’ →’Éditeur’ ,
en sélectionnant la section Raccourcis Clavier.
Figure 1.14: Dialogue de configuration des Raccourcis clavier
Sélectionner une commande dans l’arborescence des Commandes, vous affiche le raccourci
actuel pour la commande sur la droite. Sur la figure c’est Open... qui est sélectionné et le
raccourci par défaut Ctrl-O est affiché.
Pour ajouter un nouveau raccourci à la commande sélectionnée, suivre les étapes suivantes
:
1. Placer le curseur dans la boı̂te de texte au-dessous du Nouveau raccourci et presser
sur les touches, par exemple F3 ou Ctrl-A.
2. Vérifier l’assignation courante, et si une autre commande a déjà ce raccourci affecté
vous verrez son nom ici. Si le texte dit Aucun c’est que c’est bon.
Code::Blocks 29
3. Presser sur Ajouter pour ajouter le raccourci à la liste.

4. Presser sur OK dans le dialogue pour enregistrer des changements et retourner dans
l’éditeur.
1.13.4 Éditeur
Fonction Raccourci clavier
Défaire la dernière action Ctrl+Z
Refaire la dernière action Ctrl+Shift+Z
Couper le texte sélectionné Ctrl+X
Copier le texte sélectionné Ctrl+C
Coller le texte Ctrl+V
Sélectionner tout le texte Ctrl+A
Permuter en-têtes / source F11
Commenter le code surligné Ctrl+Shift+C
Décommenter le code surligné Ctrl+Shift+X
Dupliquer la ligne où est le curseur Ctrl+D
Auto-complète / Abréviations Ctrl+Space/Ctrl+J
Afficher les astuces Ctrl+Shift+Space
Permuter la ligne où est le curseur avec celle au-dessus Ctrl+T
Bascule la marque Ctrl+B
Aller à la marque précédente Alt+PgUp
Aller à la marque suivante Alt+PgDown
Changer le repliement de bloc F12
Changer tous les repliements Shift+F12
Ceci est une liste des raccourcis fournis pas le composant éditeur de Code::Blocks. Ces
raccourcis ne peuvent pas être substitués.
Code::Blocks 30

Augmenter la taille du texte. Ctrl+Keypad ”+”
Diminuer la taille du texte Ctrl+Keypad ”-”
Restituer la taille normale du texte Ctrl+Keypad ”/”
Permutation circulaire sur les fichiers récents Ctrl+Tab
Indenter le bloc. Tab
Désindenter le bloc. Shift+Tab
Supprimer jusqu’au début du mot. Ctrl+BackSpace
Supprimer jusqu’à la fin du mot. Ctrl+Delete
Supprimer jusqu’au début de ligne. Ctrl+Shift+BackSpace
Supprimer jusqu’à la fin de ligne. Ctrl+Shift+Delete
Aller en début de document. Ctrl+Home
Étendre la sélection jusqu’au début du document. Ctrl+Shift+Home
Aller au début de la ligne affichée. Alt+Home
Étendre la sélection jusqu’au début de la ligne. Alt+Shift+Home
Aller à la fin du document. Ctrl+End
Étendre la sélection jusqu’à la fin du document. Ctrl+Shift+End
Aller à la fin de la ligne affichée Alt+End
Étendre la sélection jusqu’à la fin de la ligne. Alt+Shift+End
Expand or contract a fold point. Ctrl+Keypad ”*”
Créer ou supprimer un signet Ctrl+F2
Aller au signet suivant F2
Sélectionner jusqu’au signet suivant Alt+F2
Rechercher la sélection. Ctrl+F3
Rechercher la sélection en arrière. Ctrl+Shift+F3
Défiler vers le haut. Ctrl+Up
Défiler vers le bas. Ctrl+Down
Couper la ligne. Ctrl+L
Copie de Ligne. Ctrl+Shift+T
Suppression de ligne. Ctrl+Shift+L
Permuter la Ligne avec la précédente. Ctrl+T
Dupliquer la Ligne. Ctrl+D
Recherche des conditions concordantes du
Ctrl+K
préprocesseur, passer les imbriquées
Sélectionner jusqu’aux conditions concordantes du
Ctrl+Shift+K
préprocesseur
Recherche des conditions concordantes du
Ctrl+J
préprocesseur en arrière,, passer les imbriquées.
Sélectionner en arrière jusqu’aux conditions
Ctrl+Shift+J
concordantes du préprocesseur
Paragraphe précédent. Maj étend la sélection. Ctrl+[
Paragraphe suivant. Maj étend la sélection. Ctrl+]
Mot précédent. Maj étend la sélection. Ctrl+Left
Mot suivant. Maj étend la sélection Ctrl+Right
Mot partiel précédent. Maj étend la sélection. Ctrl+/
Mot partiel suivant. Maj étend la sélection. Ctrl+\
Code::Blocks 31
1.13.5 Fichiers
Nouveau fichier ou projet Ctrl+N
Ouvrir un fichier ou un projet existant Ctrl+O
Enregistrer le fichier courant Ctrl+S
Enregistrer tous les fichiers Ctrl+Shift+S
Fermer le fichier courant Ctrl+F4/Ctrl+W
Fermer tous les fichiers Ctrl+Shift+F4/Ctrl+Shift+W
Ceci est une liste des raccourcis fournis pas le composant éditeur de Code::Blocks. Ces
raccourcis ne peuvent pas être substitués.
Activer le fichier ouvert suivant Ctrl+Tab
Activer le fichier ouvert précédent Ctrl+Shift+Tab
1.13.6 Vue
Afficher / masquer le panneau de Messages F2
Afficher / masquer le panneau de Gestion Shift+F2
Déplacer le projet vers le haut (dans l’arborescence) Ctrl+Shift+Up
Déplacer le projet vers le bas (dans l’arborescence) Ctrl+Shift+Down
Activer le précédent (dans l’arbre des projets) Alt+F5
Activer le suivant (dans l’arbre des projets) Alt+F6
Zoomer / Dézoomer Ctrl+Roll Mouse Wheel
Focus editor CTRL+Alt+E
1.13.7 Recherche
Rechercher Ctrl+F
Rechercher le suivant F3
Rechercher le précédent Shift+F3
Rechercher dans les fichiers Crtl+Shift+F
Remplacer Ctrl+R
Remplacer dans les fichiers Ctrl+Shift+R
Aller à la ligne Ctrl+G
Aller à la ligne changée suivante Ctrl+F3
Aller à la ligne changée précédente Ctrl+Shift+F3
Aller au fichier Alt+G
Aller à la fonction Ctrl+Alt+G
Aller à la fonction précédente Ctrl+PgUp
Aller à la fonction suivante Ctrl+PgDn
Aller à la déclaration Ctrl+Shift+.
Aller à l’implémentation Ctrl+.
Ouvrir le fichier inclus Ctrl+Alt+.
Code::Blocks 32
1.13.8 Générer
Générer Ctrl+F9
Compiler le fichier courant Ctrl+Shift+F9
Exécuter Ctrl+F10
Générer et exécuter F9
Re-générer Ctrl+F11
1.13.9 Debug
Débuguer F8
Continuer le débogage Ctrl+F7
Aller jusqu’au bloc de code suivant F7
Entrer dans le bloc de code Shift+F7
Aller jusqu’en sortie du bloc de code Ctrl+Shift+F7
Changer l’état du point d’arrêt F5
Exécuter jusqu’au curseur F4
Erreur précédente Alt+F1
Code::Blocks 33
2 Extensions
La plupart des extensions décrites dans ce chapitre le sont également dans le Wiki. Les
figures et les textes ont été copiés du Wiki mais adaptées pour être incluses dans des
documents Latex (Miktex 2.0).
2.1 Généralités
On peut étendre les fonctionnalités de Code::Blocks en utilisant des greffons (ou plugins,
terme que l’on gardera parfois par commodité ci-dessous). Il y a généralement trois types
de plugins :
Core plugins : extensions développées et maintenues par l’équipe de base de Code::Blocks.
Contrib plugins : extensions développées et maintenues par la communauté et recon-
nues comme étant appréciables. Elles sont donc intégrées dans le dépôt SVN de
Code::Blocks.
3rd party plugins : extensions développées et maintenues par la communauté mais pas
(encore?) dans le dépôt de Code::Blocks. Elles ont souvent leur propre dépôt ou ont
été postées (incluant le code source) dans les forums.
Si vous recherchez des plugins :
1. Regardez dans la distribution officielle. Notez que l’installateur / ”package manager”
peut vous demander d’activer spécifiquement certains des plugins. Donc LISEZ at-
tentivement.
2. Cherchez les annonces dans les forums, en particulier les forums de http://forums.
codeblocks.org/index.php/board,14.0.html.
3. Il peut y avoir des informations sur le Wiki concernant d’autres plugins dans ses
pages et ici : http://wiki.codeblocks.org/index.php/Announcement_for_plugins/
patches.
Pour les utilisateurs de Windows, le comportement par défaut de l’installateur est de
ne pas installer les ”contrib plugins”. Vous devez manuellement cocher la case ”contrib
plugin” quand on vous proposera une sélection des composants à installer. Il n’y a pas
franchement de moyen de les installer manuellement après coup.
Si vous développez des plugins : Bien sûr, vous pouvez travailler sur des plugins
comme bon vous semble, mais voici quelques suggestions:
Annoncez-les sur le ”plugin development board” dans les forums - en y incluant le code
source (initial).
OU
Créez votre propre page Web (ou utilisez une plate-forme de partage de fichiers) puis
postez le lien d’accès vers les sources/binaires/svn sur le ”plugin development board” dans
les forums.
Code::Blocks V2.0.1 beta 2.2 Astyle
OU
Créez un dépôt, par exemple sur BerliOS ou SourceForge, postez le lien d’accès vers
les sources/binaires/svn sur le ”plugin development board” dans les forums. Veuillez
noter : C’est la meilleure façon de faire car les fichiers attachés dans nos forums peuvent
être supprimés de temps en temps. Ce n’est donc pas très sûr de poster du code dans les
forums.
ENFIN
Entrez la description des plugins sur cette page.
Annoncez le plugin en utilisant le formulaire sur http://wiki.codeblocks.org/index.
php/Template_for_plugin_announcement
2.2 Astyle
Artistic Style est un indenteur de code source, un formateur de code source et un em-
bellisseur de code source pour les langages de programmation C, C++, C#. Il peut être
utilisé pour sélectionner différents styles de règles de codage dans les Code::Blocks.
Figure 2.1: Formater votre code source
Quand on indente un code source, nous en tant que programmeurs avons tendance à
utiliser à la fois des espaces et des caractères de tabulations pour créer l’indentation
souhaitée. De plus, certains éditeurs insèrent par défaut des espaces à la place des tab-
ulations quand on appuie sur la touche Tab, alors que d’autres éditeurs ont la faculté
de rendre d’embellir les lignes en ajoutant automatiquement des espaces en début de
lignes, éventuellement en remplaçant dans ce code les tabulations utilisées jusqu’alors
pour l’indentation par des espaces.
Code::Blocks 35
Code::Blocks V2.0.1 beta 2.3 AutoVersioning
Comme le nombre de caractères affichés sur l’écran pour chaque caractère de tabulation
change d’un éditeur à l’autre, un des problèmes courants auquel est confronté un pro-
grammeur qui passe d’un éditeur à un autre est qu’un code qui contient à la fois des
espaces et des tabulations et qui était jusqu’à présent bien indenté, devient soudain dif-
ficile à regarder après le changement d’éditeur. Même si en tant que programmeur vous
faites attention à n’utiliser QUE des espaces ou QUE des tabulations, récupérer un code
de quelqu’un d’autre peut malgré tout être problématique.
C’est pour résoudre ce problème qu’Artistic Style a été créé - un filtre écrit en C++ qui
ré-indente et reformate automatiquement les fichiers sources en C / C++ / C#.
Note :
Quand vous copiez du code, par exemple depuis Internet ou d’un
manuel, ce code sera automatiquement adapté aux règles de codage
dans Code::Blocks.
2.3 AutoVersioning
Une application de suivi de versions qui incrémente les numéros de version et de génération
de votre application à chaque fois qu’un changement est effectué et l’enregistre dans un
fichier version.h avec des déclarations de variables faciles à utiliser. Possède également
une option pour proposer des changements dans un style à la SVN, un éditeur de schémas
de versions, un générateur de journal des changements, et bien d’autres choses encore . . .
2.3.1 Introduction
L’idée de développer l’extension AutoVersioning est venue lors du développement d’un
logiciel en version pre-alpha qui exigeait des informations de version et d’état. Trop oc-
cupé par le codage, sans temps disponible pour maintenir la numérotation des versions,
l’auteur a décidé de développer une extension qui puisse faire le travail avec aussi peu
d’interventions que possible.
Voici résumée la liste des fonctions couvertes par l’extension :
Supporte C et C++.
Génère et incrémente automatiquement des variables de versions.
Éditeur de l’état du logiciel.
Éditeur de schéma intégré pour changer le comportement de l’auto incrémentation
des valeurs de versions.
Déclaration des dates en mois, jour et année.
Style de version Ubuntu.
Contrôle des révisions Svn.
Code::Blocks 36
Générateur de journal des changements.

Fonctionne sous Windows et Linux.
2.3.3 Utilisation
Aller simplement dans le menu ’Projet’ →’Autoversioning’ . Une fenêtre popup comme
celle-ci apparaı̂tra :
Figure 2.2: Configuration d’un projet pour Autoversioning
Quand on répond Oui au message de demande de configuration, la fenêtre principale de

configuration d’AutoVersioning s’ouvre pour vous permettre de paramétrer les informa-
tions de version de votre projet.
Après avoir configuré votre projet pour la mise en version automatique, les paramètres
entrés dans la boı̂te de dialogue de configuration sont enregistrées dans le fichier de projet
et un fichier version.h est créé. Pour le moment, chaque fois que vous entrez dans le menu
’Projet’ →’Autoversioning’ , le dialogue de configuration qui apparaı̂t vous permet d’éditer
votre version de projet et les paramètres qui y sont liés, à moins que vous n’enregistriez
pas les nouveaux changements effectués par l’extension dans le fichier de projet.
2.3.4 Onglets de la boı̂te de dialogue

Valeurs de Version
Ici vous entrez simplement les valeurs de version adéquates ou laissez l’extension Autover-
sioning le faire pour vous (voir Figure 2.3 à la page 38).
Version Majeure Incrémenté de 1 quand le numéro mineur atteint son maximum
Version mineure Incrémenté de 1 quand le numéro de génération dépasse la barrière
de nombre de générations, la valeur étant remise à 0 quand il atteint sa valeur
maximale.
Numéro de génération (également équivalent à numéro de Release) - Incrémenté de 1
chaque fois que le numéro de révision est incrémenté.
Révision Incrémenté aléatoirement quand le projet a été modifié puis compilé.
État
Quelques champs pour garder une trace de l’état de votre logiciel avec une liste de valeurs
prédéfinies usuelles (voir Figure 2.4 à la page 38).
Code::Blocks 37
Figure 2.3: Configuration des Valeurs de Version
État du logiciel Un exemple typique pourrait être v1.0 Alpha

Abréviation Idem à l’état du logiciel mais comme ceci : v1.0a
Figure 2.4: Configuration de l’État dans Autoversioning
Code::Blocks 38
Schéma
Vous permet d’éditer comment l’extension incrémentera les valeurs de version (voir Fig-
ure 2.5 à la page 39).
Figure 2.5: Schéma de fonctionnement d’Autoversioning
Valeur max pour numéro mineur Valeur maximale que peut atteindre la valeur mineure.
Une fois cette valeur atteinte, le numéro Majeur est incrémenté de 1 et à la compi-
lation suivante le numéro mineur sera remis à 0.
Nombre max de générations Quand cette valeur est atteinte, le compteur sera remis à
0 à la génération suivante. Mettre à 0 pour ne pas limiter.
Révision maximale Comme Nombre max de générations. Mettre à 0 pour ne pas limiter.
Révision aléatoire maximale Les révisions s’incrémentent par un nombre aléatoire que
vous décidez. Si vous mettez 1, les révisions s’incrémenteront évidemment par 1.
Nombre de générations avant d’incrémenter Mineur Après des changements de code
et des compilations avec succès, l’historique des générations s’incrémente, et quand
cette valeur est atteinte alors la valeur Mineure s’incrémente.
Paramètres
Ici vous pouvez entrer certains paramètres du comportement d’Autoversioning (voir Fig-
ure 2.6 à la page 40).
Auto-incrémente Majeur et Mineur Laisse l’extension incrémenter ces valeurs en util-
isant le schéma. Si non coché, seuls les numéros de génération et de Révision
s’incrémenteront.
Code::Blocks 39
Figure 2.6: Paramètres d’Autoversioning
Créer des déclarations de dates Crée des entrées dans le fichier version.h avec des
dates et un style de version à la façon d’Ubuntu.
Incrémentation automatique Indique à l’extension d’incrémenter automatiquement dès
qu’une modification est faite. Cette incrémentation interviendra avant la compila-
tion.
Langage de l’en-tête Sélectionne le langage de sortie du fichier version.h
Interroger pour incrémenter Si Incrémentation automatique est coché, on vous inter-
roge alors avant la compilation (si des changements ont été effectués) pour incrémenter
les valeurs de version.
Svn activé Recherche dans le répertoire courant la révision Svn et la date puis génère les
entrées correspondantes dans version.h
Journal des changements
Ceci vous permet d’entrer chaque changement effectué au projet afin de générer un fichier
ChangesLog.txt (voir Figure 2.7 à la page 41).
Afficher les changements quand la version s’incrémente Affichera une fenêtre popup
d’édition de journal quand la version est incrémentée.
Format du Titre Un titre formaté avec une liste de valeurs prédéfinies.
Code::Blocks 40
Figure 2.7: Journal des changements d’Autoversioning
2.3.5 Inclusion dans votre code

Pour utiliser les variables générées par l’extension faire simplement #include <version.h>.
Le code suivant est un exemple de ce qu’on peut faire :
#include <i o s t r e a m >
#include ” v e r s i o n . h”
void main ( ) {
s t d : : cout<<AutoVersion : : Major<<e n d l ;
}
Sortie de version.h
Le fichier d’en-tête généré. Voici un exemple sur un fichier en mode c++ :
#i f n d e f VERSION H
#define VERSION H
namespace AutoVersion {
// Date V e r s i o n Types
static const char DATE [ ] = ” 15 ” ;
static const char MONTH[ ] = ” 09 ” ;
static const char YEAR [ ] = ” 2007 ” ;
static const double UBUNTU VERSION STYLE = 7 . 0 9 ;
// S o f t w a r e S t a t u s
s t a t i c const char STATUS [ ] = ” Pre=a l p h a ” ;
Code::Blocks 41
s t a t i c const char STATUS SHORT [ ] = ”pa” ;
// Standard V e r s i o n Type
s t a t i c const long MAJOR = 0 ;
s t a t i c const long MINOR = 1 0 ;
s t a t i c const long BUILD = 1 0 8 6 ;
s t a t i c const long REVISION = 6 3 4 9 ;
// M i s c e l l a n e o u s V e r s i o n Types
s t a t i c const long BUILDS COUNT = 1 9 8 4 ;
#d e f i n e RC FILEVERSION 0 , 1 0 , 1 0 8 6 , 6 3 4 9
#d e f i n e RC FILEVERSION STRING ” 0 , 1 0 , 1 0 8 6 , 6349\0 ”
s t a t i c const char FULLVERSION STRING [ ] = ” 0 . 1 0 . 1 0 8 6 . 6 3 4 9 ” ;
}
#endif //VERSION h
En mode C c’est la même chose qu’en C++ mais sans le namespace:

#i f n d e f VERSION H
#define VERSION H
// Date V e r s i o n Types
static const char DATE [ ] = ” 15 ” ;
static const char MONTH[ ] = ” 09 ” ;
static const char YEAR [ ] = ” 2007 ” ;
static const double UBUNTU VERSION STYLE = 7 . 0 9 ;
// S o f t w a r e S t a t u s
s t a t i c const char STATUS [ ] = ” Pre=a l p h a ” ;
s t a t i c const char STATUS SHORT [ ] = ”pa” ;
// Standard V e r s i o n Type
s t a t i c const long MAJOR = 0 ;
s t a t i c const long MINOR = 1 0 ;
s t a t i c const long BUILD = 1 0 8 6 ;
s t a t i c const long REVISION = 6 3 4 9 ;
// M i s c e l l a n e o u s V e r s i o n Types
s t a t i c const long BUILDS COUNT = 1 9 8 4 ;
#d e f i n e RC FILEVERSION 0 , 1 0 , 1 0 8 6 , 6 3 4 9
#d e f i n e RC FILEVERSION STRING ” 0 , 1 0 , 1 0 8 6 , 6349\0 ”
s t a t i c const char FULLVERSION STRING [ ] = ” 0 . 1 0 . 1 0 8 6 . 6 3 4 9 ” ;
#endif //VERSION h
2.3.6 Générateur de journal des changements

Cette boı̂te de dialogue est accessible à partir du menu ’Projet’ →’ Journal des change-
ments’ . Également si la case ”Afficher l’éditeur des changements quand la version s’incrémente”
Code::Blocks 42
est cochée, une fenêtre s’ouvrira pour vous permettre d’entrer la liste des changements
après une modification des sources du projet ou un évènement d’incrémentation (voir
Figure 2.8 à la page 43).
Figure 2.8: Changements dans un projet
Résumé des Boutons

Ajouter Ajoute une ligne à la grille de données
Éditer Active les modifications de la cellule sélectionnée
Supprimer Supprime la ligne courante de la grille de données
Enregistrer Enregistre dans un fichier temporaire (changes.tmp) les données actuelles
pour pouvoir effectuer plus tard les entrées dans le journal des changements
Écrire Entre la grille de données dans le journal des changements
Annuler Ferme simplement la boı̂te de dialogue sans rien faire d’autre
Voici un exemple de sortie générée par l’extension dans le fichier ChangesLog.txt :
03 September 2007
r e l e a s e d v e r s i o n 0 . 7 . 3 4 o f AutoVersioning =Linux
Change l o g :
= Fixed : p o i n t e r d e c l a r a t i o n
=Bug : b l a h b l a h
02 September 2007
Change l o g :
=Documented some a r e a s o f t h e code
Code::Blocks 43
Code::Blocks V2.0.1 beta 2.4 Browse Tracker
= R e o r g a n i z e d t h e code f o r r e a d a b i l i t y
01 September 2007
Change l o g :
= E di te d t h e change l o g window
= I f t h e change l o g windows i s l e a v e blank no c h a n g e s . t x t i s m o d i f i e d
2.4 Browse Tracker

Browse Tracker est une extension qui aide à naviguer parmi les fichiers récemment ouverts
dans Code::Blocks. La liste des fichiers récents est sauvegardée dans un historique. Le
menu ’Vue’ →’Suivi de Navigation’ →’Tout Effacer’ permet d’effacer l’historique.
Dans les différents ’onglets’ vous pouvez naviguer entre les divers éléments des fichiers
récemment ouverts en utilisant l’entrée de menu ’Vue’ →’Suivi de Navigation’ →’Aller
en arrière/Aller en avant’ ou en utilisant les raccourcis claviers Alt-Gauche/Alt-Droit.
Le menu de suivi de navigation est également accessible dans les menus de contexte. Les
marqueurs sont enregistrés dans un fichier de mise en page <projectName>.bmarks
Quand on développe du logiciel, on passe souvent d’une fonction à une autre implémentée
dans différents fichiers. L’extension de suivi de navigation vous aidera dans cette tâche
en vous montrant l’ordre dans lequel ont été sélectionnés les fichiers. Vous pouvez alors
naviguer confortablement dans les différents appels de fonctions.
L’extension permet même de naviguer entre les marqueurs de chaque fichier de l’éditeur de
Code::Blocks. La position du curseur est mémorisée pour chacun des fichiers. Vous pouvez
poser ces marqueurs en utilisant le menu ’Vue’ →’ Suivi de Navigation’ →’ Activer le
marquage de navigation’ ou en sélectionnant une ligne avec le bouton gauche de la souris.
Une marque . . . est alors posée dans la marge gauche. Avec les menus ’Vue’ →’Suivi de
Navigation’ →’Marque précédente/Marque suivante’ ou les raccourcis Alt-up/Alt-down
vous pouvez naviguer entre les différents marques posées dans un fichier. Si vous voulez
naviguer dans un fichier avec des marques triées en fonction du numéro de lignes, choisissez
simplement le menu ’Vue’ →’Suivi de Navigation’ →’Trier les marques de navigation’ .
En choisissant ’Effacer la marque de navigation’ le marqueur de la ligne sélectionnée
est supprimé. Si un marqueur est posé sur une ligne, le fait d’appuyer pendant 1/4 de
seconde sur le bouton gauche de la souris tout en appuyant sur la touche Ctrl effacera le
marqueur de cette ligne. Avec le menu ’Effacer toutes les marques de navigation’ ou avec
un Ctrl-clic gauche sur toute ligne non marquée, vous remettez à 0 tous les marqueurs
d’un fichier.
Le paramétrage de l’extension peut être configuré via le menu ’Paramètres’ →’Éditeur’
→’Browse Tracker’ .
Note :
NdT : certains menus ou affichages ne sont pas traduits car l’auteur de
l’extension n’a pas marqué certaines chaı̂nes comme étant traduisibles
Code::Blocks 44
Code::Blocks V2.0.1 beta 2.5 CodeSnippets
Mark Style (Styles des marques) Les marques de navigation sont affichées par défaut
comme des . . . dans la marge. Avec le choix ’Book Marks’ elles seront affichées
en tant que marque par une flèche bleue dans la marge. L’option ”hide” supprime
l’affichage des marques.
Toggle Browse Mark key Les marques peuvent être activées ou supprimées soit par un
simple clic avec le bouton gauche de la souris soit avec un clic-gauche tout en
maintenant la touche Ctrl enfoncée.
Toggle Delay Durée pendant laquelle le bouton gauche de la souris est enfoncé pour
entrer dans le mode de marquage de navigation.
Clear All BrowseMarks (Effacer toutes les marques) tout en maintenant enfoncée la
touche Ctrl soit par simple clic soit par double-clic sur le bouton gauche de la
souris.
La configuration de l’extension est enregistrée dans votre répertoire application data dans
le fichier default.conf. Si vous utilisez la fonctionnalité des profils (ou personnalité) de
Code::Blocks la configuration est alors lue dans votre fichier <personality>.conf.
2.5 CodeSnippets
L’extension CodeSnippets permet de structurer des modules de texte et des liens vers des
fichiers en fonction de catégories dans une vue arborescente. Les modules sont utilisés
pour stocker des fichiers fréquemment utilisés, des constructions de modules de texte, le
tout géré depuis un endroit centralisé. Imaginez la situation suivante : Un certain nombre
de fichiers source fréquemment utilisés sont stockés dans divers répertoires du système de
fichiers. La fenêtre de CodeSnippets vous donne l’opportunité de créer des catégories et,
à l’intérieur de ces catégories, des liens vers les fichiers requis. Avec cette fonctionnalité,
vous pouvez contrôler l’accès aux fichiers indépendamment de l’endroit où ils sont stockés
dans le système de fichiers, et vous pouvez rapidement naviguer entre ces fichiers sans
avoir besoin de les chercher un peu partout dans le système.
Note :
Vous pouvez utiliser les variables Code::Blocks ou les vari-
ables d’environnement dans les liens vers les fichiers comme
$(VARNAME)/name.pdf pour paramétrer un lien dans le navigateur
de CodeSnippets.
La liste des modules de texte et des liens peut être enregistrée dans la fenêtre des
CodeSnippets en cliquant sur le bouton droit de la souris et en sélectionnant ’Enregistrer
l’index’ depuis le menu de contexte. Le fichier codesnippets.xml qui est alors créé par
cette procédure, se trouve dans le sous-répertoire codeblocks du répertoire Documents
and Settings\Application data. Sous Linux, cette information est enregistrée dans le
sous-répertoire .codeblocks de votre répertoire HOME. Les fichiers de configuration de
Code::Blocks seront chargés au démarrage suivant. Si vous souhaitez enregistrer le con-
tenu des CodeSnippets à un autre endroit, sélectionnez l’entrée ’Enregistrer l’index sous’.
Code::Blocks 45
Pour charger ce fichier, sélectionnez ’Charger le fichier d’index’ lors du démarrage suivant
de Code::Blocks ou incluez le répertoire dans les ’Paramètres’ du menu de contexte de
’Répertoire des Snippets’. Les paramétrages sont enregistrés dans le fichier correspondant
codesnippets.ini dans votre application data.
Pour inclure une catégorie, utilisez le menu ’Ajouter une sous-catégorie’. Une catégorie
peut contenir des Snippets (modules de texte) ou des Liens vers un fichier. Un module
de texte est créé via la commande ’Ajouter un Snippet’ depuis le menu de contexte. Le
contenu est intégré dans le module de texte comme un ’Nouveau snippet’ en sélectionnant
un passage de texte dans l’éditeur de Code::Blocks et en le glissant-déposant sur le module
dont les propriétés s’affichent. En double-cliquant sur la nouvelle entrée ou en sélectionnant
’Éditer le Texte’ on en éditera le contenu.
Figure 2.9: Édition d’un module de texte
La sortie d’un module de texte est gérée dans Code::Blocks via la commande ’Appliquer’
du menu de contexte ou en faisant un glisser-déposer dans l’éditeur. Sous Windows, le
contenu d’un Snippet peut également être glissé-déposé dans d’autres applications. Dans
le navigateur de CodeSnippets vous pouvez copier une sélection par glisser-déposer vers
une catégorie différente.
De plus, les modules de texte peuvent être paramétrés par des variables <name> qui
peuvent être accédées via $(name) (voir Figure 2.9 à la page 46). Les valeurs des variables
peuvent être récupérées dans un champ d’entrée si le module de texte est appelé via la
commande du menu de contexte ’Appliquer’.
À côté des modules de texte, des liens vers des fichiers peuvent aussi être créés. Si, après
avoir créé un module de texte, vous cliquez sur la commande ’Propriétés’ du menu de
contexte, vous pouvez alors sélectionner une cible de type lien en cliquant sur le bouton
’Lien cible’. Cette procédure convertira automatiquement le module de texte en un lien
vers un fichier. Dans CodeSnippets, tous les modules de texte sont marqués par un symbole
T, les liens vers un fichier par un symbole F et les urls par un symbole U. Si vous
voulez ouvrir un fichier sélectionné (lien) dans la vue des codesnippets, sélectionnez tout
simplement le menu de contexte ’Ouvrir le fichier’ ou tout en maintenant enfoncée la
touche ’Alt’ effectuez un double-clic sur le fichier.
Note :
Vous pouvez même ajouter une url (comme
http://www.codeblocks.org) dans les modules de texte. L’url
peut être ouverte en utilisant le menu de contexte ’Ouvrir l’Url’ ou
en utilisant un glisser-déposer vers votre navigateur favori.
Code::Blocks 46
Avec un tel paramétrage, si vous ouvrez un lien vers un fichier pdf depuis la vue des
codesnippets, un visualiseur de fichiers pdf sera automatiquement démarré. Cette méthode
rend possible à l’utilisateur l’accès à des fichiers répartis un peu partout sur le réseau,
comme des données, mises en forme, documentations etc., à l’aide des applications com-
munes, simplement par le biais d’un lien. Le contenu des codesnippets est enregistré dans le
fichier codesnippets.xml, la configuration est enregistrée dans le fichier codesnippets.ini
de votre répertoire application data. Ce fichier ini contiendra, par exemple, le chemin
du fichier codesnippets.xml.
Figure 2.10: Vue des CodeSnippets
Code::Blocks supporte l’utilisation de différents profils. Ces profils sont aussi nommés
personnalités. En démarrant, avec l’option --personality=<profile>, Code::Blocks en
ligne de commande vous créez ou utilisez un profil existant. Dans ce cas, le paramétrage ne
sera pas enregistré dans le fichier default.conf, mais plutôt dans un <personality>.conf
de votre répertoire application data. L’extension Codesnippets enregistrera alors ses
paramètres dans un fichier <personality>.codesnippets.ini. Maintenant, si vous
chargez un nouveau contenu <name.xml> dans les paramètres de codesnippets via ’Charger
un fichier d’index’, ce contenu sera enregistré dans le fichier ini correspondant. L’avantage
de cette méthode tient dans le fait que dans le cas où il y a différents profils, on peut
gérer plusieurs configurations de modules de textes et de liens.
L’extension offre une fonction de recherche complémentaire pour naviguer dans les catégories
et les Snippets. La façon de rechercher dans les Snippets, catégories ou Snippets et
catégories peut s’ajuster. En entrant l’expression de recherche requise, l’entrée correspon-
dante est automatiquement sélectionnée dans la vue. La Figure 2.10 à la page 47 affiche
Code::Blocks 47
Code::Blocks V2.0.1 beta 2.6 Doxyblocks
une fenêtre CodeSnippets typique.
Note :
Quand on utilise des modules de texte volumineux, le contenu de ces
modules devrait être enregistré sous forme de fichiers via ’Convertir en
lien vers fichier’ de façon à réduire l’utilisation mémoire du système. Si
vous supprimez un codesnippet ou un lien vers un fichier, il est en fait
déplacé vers la corbeille (ou un répertoire .trash); si vous maintenez
la touche Maj enfoncée, cet élément sera réellement détruit.
2.6 Doxyblocks
DoxyBlocks est une extension pour Code::Blocks qui intègre doxygen dans l’IDE. Il vous
permet de créer de la documentation, insérer des blocs de commentaires et de lancer des
documents HTML ou CHM. Il fournit également la configuration de quelques-uns des
paramètres les plus communément utilisés at un accès à doxywizard pour obtenir une
configuration plus détaillée.
Les paramètres de la barre d’outils de DoxyBlocks ont la signification suivante :
Lancer doxywizard. Ctrl-Alt-D
Extraire la documentation du projet courant. Ctrl-Alt-E
Insère un bloc de commentaires sur la ligne courante. De plus, DoxyBlocks essaiera

de façon intelligente de lire si une méthode existe dans la ligne où le commentaire
est en train d’être ajouté. Ctrl-Alt-B
/* * \ b r i e f
*
* \param bar b o o l
* \ return void
*
*/
void MyClass : : Foo ( b o o l bar )
{
foo Bar ( bar ) ;
}
Insère une ligne de commentaire à la position actuelle du curseur. Ctrl-Alt-L

void MyClass : : Foo ( b o o l bar )
{
foo Bar ( bar ) ; / **< * /
}
Affiche la documentation HTML générée. Ctrl-Alt-H
Code::Blocks 48
Code::Blocks V2.0.1 beta 2.6 Doxyblocks
Affiche la documentation CHM (Help) générée. Ctrl-Alt-C
Ouvre les préférences de DoxyBlocks. Ctrl-Alt-P

Doxyblocks ne peut travailler que si doxygen est installé sur votre système. Vous avez
besoin au moins des exécutables de doxygen et de doxywizard (disponibles dans la dis-
tribution officielle de doxygen sur http://www.doxygen.nl/). En option, vous pouvez
avoir l’exécutable ”dot” du package graphviz (voir https://graphviz.gitlab.io/. Sous
Windows, le compilateur d’aide (hhc) peut également être utilisé les fichiers de type chm.
Notes
Dans les préférences, vous avez une case à cocher qui autorise ou pas DoxyBlocks à
écraser le fichier doxyfile. Par défaut, si un doxyfile existe déjà il ne sera pas
écrasé pour protéger de divers changements qui auraient pu être faits en dehors
de DoxyBlocks. Néanmoins ce comportement empèche aux changements faits par
DoxyBlocks lui-même d’être écrits dans le doxyfile existant.
Si un champ de texte des ”Préférences” est vide, DoxyBlocks assumera que l’exécutable
correspondant est disponible quelquepart via votre variable d’environnement path.
Vous pouvez utiliser des macros telles que $(CODEBLOCKS) dans votre path et
elles seront automatiquement étendues.
OUTPUT DIRECTORY Utilisé pour spécifier le chemin de base (relatif ou absolu) ou
sera enregistrée la documentation générée. Si un chemin relatif est entré, il sera en
relatif par rapport à l’emplacement d’où doxygen a été lancé. Si laissé en blanc,
c’est le répertoire courant qui sera utilisé. Doxyblocks utilisera le nom de chemin
entré ici pour créer un répertoire relatif au <rep. projet>. Ceci vout permet de créer
des répertoire doxygen différents pour des projets inclus dans un même répertoire,
ou simplement utiliser un nom de répertoire différent. Si le champ est laissé en
blanc, les documents seront créés dans ”<rep. projet>/doxygen”. Entrer les noms de
répertoires sans points, ni séparateurs de tête, ni nom de volume, etc. DoxyBlocks
effectue la validation sur le nom de chemin et supprime les caractères en trop.
Exemples:
[blanc] -> <répertoire projet>/doxygen.
"docs" -> <répertoire projet>/docs.
"docs/sub1/sub2" -> <répertoire projet>/docs/sub1/sub2.
"doxygen/docs" -> <répertoire projet>/doxygen/docs.
OUTPUT LANGUAGE Utilisé pour spécifier dans quelle langue sera générée la doc-
umentation par doxygen. Doxygen utilisera cette information pour générer toutes
les sorties constantes dans la langue adéquate. La langue par défaut est l’anglais.
D’autres langues sont supportées.
D’autres informations dans les fichiers d’aide de doxygen
Code::Blocks 49
Code::Blocks V2.0.1 beta 2.7 Extension Editor Tweaks
2.7 Extension Editor Tweaks

Le plugin EditorTweaks (modifications d’édition) apporte plusieurs fonctionnalités différentes.
Sur une base de travail fichier à fichier, il contrôle :
le repliement de mots ;
la numérotation des lignes ;
l’interprétation de la touche tab (caractère de tabulation ou espaces) ;
le nombre de caractères espace remplaçant la touche tab ;
les caractères de fin de ligne (carriage-return + linefeed; carriage-return; linefeed) ;
la visualisation des caractères de fin de ligne ;
sur demande, la suppression des espaces blancs en fin de ligne ;
sur demande, la synchronisation des caractères de fin de ligne ;
la suppression de la touche d’insertion.
Depuis la fusion avec le plugin ”Aligner”, il peut rendre des sections de code plus lisibles
en les alignant sur un caractère spécifique.
Par exemple, aligner sur le caractère ”=” dans :
int var = 1 ;
int longVarName = 2 ;
int f o o b a r = 3 ;
se traduira par :
int var = 1;
int longVarName = 2 ;
int f o o b a r = 3;
2.8 Extensions FileManager et PowerShell

L’explorateur de fichiers Figure 2.11 à la page 51 est inclus dans l’extension FileManager,
et se trouve dans l’onglet ’Fichiers’. L’aspect de File Explorer est montré à la Figure 2.11
à la page 51.
En haut vous trouverez le champ d’entrée du chemin. En cliquant sur le bouton à
l’extrémité de ce champ, la flèche vers le bas listera un historique des entrées précédentes
dans lesquelles on peut naviguer à l’aide d’une barre de défilement. La flèche vers le haut
à droite du champ déplace d’un cran vers le haut dans la structure des répertoires.
Dans le champ ’Joker’ vous pouvez entrer un filtre de visualisation pour l’affichage des
fichiers. En laissant vide ce champ ou en y entrant * vous afficherez tous les fichiers. En y
entrant *.c ;*. h par exemple, vous n’afficherez que les fichiers sources en C et les fichiers
d’en-têtes (headers). Ouvrir la flèche du bas, affiche de nouveau la liste des dernières
entrées.
Code::Blocks 50
Code::Blocks V2.0.1 beta 2.8 Extensions FileManager et PowerShell
Figure 2.11: Le gestionnaire de fichiers
Appuyer sur la touche Maj tout en cliquant, sélectionne un groupe de fichiers ou de

répertoires, alors qu’appuyer sur la touche Ctrl tout en cliquant sélectionne des fichiers
multiples ou des répertoires séparés.
Les opérations suivantes peuvent être obtenues via le menu de contexte si un ou plusieurs
répertoires ont été sélectionnés dans l’Explorateur de Fichiers :
Make Root défini le répertoire courant comme répertoire de base.
Ajouter aux favoris configure un marqueur pour ce répertoire et l’enregistre dans les fa-
voris. Cette fonction permet de naviguer rapidement entre des répertoires fréquemment
utilisés ou encore sur des disques réseau.
Nouveau Fichier crée un nouveau fichier dans le répertoire sélectionné.
Nouveau Répertoire crée un nouveau sous répertoire dans le répertoire sélectionné.
fichiers ou même un ou plusieurs répertoires ont été sélectionnés dans l’Explorateur de
Fichiers :
Dupliquer copie un fichier/répertoire et le renomme.
Copier vers ouvre une boı̂te de dialogue pour entrer un répertoire cible dans lequel on
Code::Blocks 51
copiera les fichiers/répertoires.

Déplacer vers déplace la sélection vers un autre endroit.
Supprimer supprime les fichiers/répertoires sélectionnés.
Afficher les fichiers masqués active/désactive l’affichage des fichiers systèmes masqués.
Si activé, le menu est coché par un marqueur.
Actualiser actualise l’affichage de l’arborescence des répertoires.
fichiers ont été sélectionnés dans l’Explorateur de Fichiers :
Ouvrir dans l’éditeur CB ouvre le fichier sélectionné dans l’éditeur de Code::Blocks.
Renommer renomme le fichier sélectionné.
Ajouter au projet actif ajoute le(s) fichier(s) au projet actif.
Note :
Les fichiers/répertoires sélectionnés dans l’explorateur de fichiers peu-
vent être accédés dans l’extension PowerShell à l’aide de la variable
mpaths.
On peut spécifier via la commande de menu ’Paramètres’ →’Environnement’ →’PowerShell’

des fonctions utilisateur. Dans le masque de PowerShell, une nouvelle fonction qui peut
être nommée aléatoirement, est créée via le bouton ’Nouveau’. Dans le champ ’ShellCom-
mand Executable’, le programme exécutable est spécifié, et dans le champ en bas de la
fenêtre, des paramètres additionnels peuvent être passés au programme. En cliquant sur
la fonction dans le menu de contexte ou dans le menu de PowerShell, la fonction s’exécute
et traite les fichiers/répertoires sélectionnés. La sortie est redirigée vers une fenêtre de
Shell séparée.
Par exemple une entrée de menu a été créée dans ’PowerShell’ →’SVN’ et dans le menu
de contexte en tant que ’SVN’. Dans ce contexte $le signifie le fichier sélectionné dans
l’explorateur de fichiers, $mpath les fichiers ou répertoires sélectionnés (voir section 3.2 à
la page 83).
A j o u t e r ; $ i n t e r p r e t e r add $ mpaths ; ; ;
Celle-ci et toutes les commandes suivantes créeront un sous-menu, dans ce cas ’Extensions’
→’SVN’ →’Ajouter’ . Le menu de contexte est étendu de même. Cliquez sur la commande
du menu de contexte pour faire exécuter la commande SVN add sur les fichiers/répertoires
sélectionnés.
TortoiseSVN est un programme SVN très répandu qui s’intègre dans l’explorateur. Le
programme TortoiseProc.exe de TortoiseSVN peut être démarré en ligne de commande
et affiche une boı̂te de dialogue pour y entrer les données de l’utilisateur. Ainsi vous pouvez
lancer des commandes, disponibles en tant que menus de contexte dans l’explorateur,
également en ligne de commande. Vous pouvez donc l’intégrer en tant qu’extension du
Shell dans Code::Blocks. Par exemple, la commande
Code::Blocks 52
T o r t o i s e P r o c . exe /command : d i f f / path : $ f i l e
affichera les différences entre un fichier sélectionné dans l’explorateur de Code::Blocks et

celui de la base de SVN. Voir Figure 2.12 à la page 53 comment intégrer cette commande.
Note :
Pour les fichiers qui sont sous le contrôle de SVN l’explorateur de
fichier affiche des icônes superposées qui s’activent via le menu ’Vue’
→’SVN Decorators’ .
Figure 2.12: Ajout d’une extension Shell au menu de contexte
Exemple
Vous pouvez utiliser l’explorateur de fichiers pour afficher les différences sur des fichiers
ou des répertoires. Suivez les étapes suivantes :
1. Ajoutez le nom via le menu ’Paramètres’ →’Environnement’ →’PowerShell’ . C’est
affiché comme une entrée par l’interpréteur de menu et le menu de contexte.
2. Sélectionnez le chemin absolu de l’exécutable Diff (notamment kdiff3). Le pro-
gramme est accédé avec la variable $interpreter .
3. Ajoutez les paramètres de l’interpréteur
D i f f ; $ i n t e r p r e t e r $ mpaths ; ; ;
Cette commande sera exécutée en utilisant les fichiers ou répertoires sélectionnés en tant
que paramètres. La sélection peut être accédée via la variable $mpaths. Ceci est une façon
commode de différentier des fichiers ou des répertoires.
Code::Blocks 53
Code::Blocks V2.0.1 beta 2.9 Éditeur Hexadécimal
Note :
L’extension supporte l’utilisation des variables de Code::Blocks dans
l’extension du Shell.
$interpreter Appelle cet exécutable.
$fname Nom du fichier sans son extension.
$fext Extension du fichier sélectionné.
$file Nom du fichier.
$relfile Nom du fichier sans l’information de chemin.
$dir Nom du répertoire sélectionné.
$reldir Nom du répertoire sans l’information de chemin.
$path Chemin absolu.
$relpath Chemin relatif du fichier ou du répertoire
$mpaths Liste des fichiers et répertoires sélectionnés actuellement
$inputstr{<msg>} Chaı̂ne de caractères qui est entrée dans une fenêtre de message.
$parentdir Répertoire Parent (../).
Note :
Les entrées de l’extension Shell sont également disponibles en tant
que menus de contexte dans l’éditeur de Code::Blocks.
2.9 Éditeur Hexadécimal

Comment ouvrir un fichier via HexEditor dans Code::Blocks.
1. ’Fichier’ →’ Ouvrir avec HexEditor’
2. Menu contextuel du navigateur de projet (’Ouvrir avec’ →’Hex editor’
3. Sélectionnez l’onglet Fichier dans le panneau de gestion. En sélectionnant un fichier
dans le Gestionnaire de fichiers et en exécutant le menu contextuel ’Ouvrir avec Hex
Editor’ , le fichier s’ouvre dans HexEditor.
Répartition des fenêtres :
À gauche la Vue de HexEditor et à droite l’affichage sous forme de chaı̂nes de caractères
Ligne du haut : Position actuelle (valeur en décimal/hex) et pourcentage (rapport entre
la position actuelle du curseur et le fichier complet).
Boutons:
Fonctions de recherche
Code::Blocks 54
Code::Blocks V2.0.1 beta 2.10 Recherche Incrémentale
Bouton Aller à : Sauter à une position absolue. Format décimal ou hexadécimal. Saut
relatif vers l’avant ou vers l’arrière en spécifiant le signe.
Chercher: Recherchez des motifs hexadécimaux dans la vue HexEditor ou des chaı̂nes de
caractères dans la vue d’aperçu de fichier.
Configuration du nombre de colonnes : Exactement, Multiple de, Puissance de
Mode d’affichage : Hexa, Binaire
Octets : Sélectionnez le nombre d’octets à afficher par colonne.
Choix d’Endianess : BE: Big Endian LE: Little Endian
Valeur Prévisualisée : Ajoute une vue supplémentaire dans HexEditor. Pour une valeur
sélectionnée dans HexEditor, la valeur est également affichée sous forme de Word, Dword,
Float, Double.
Entrée d’expression : Permet d’effectuer une opération arithmétique sur une valeur dans
HexEditor. Le résultat de l’opération est affiché dans la marge de droite.
Calc: Testeur d’Expression
Édition d’un fichier dans HexEditor :
Commandes d’historique Annuler (Undo) et Refaire (Redo).
Autre exemple, Déplacer le curseur dans la vue des chaı̂nes de caractères : Insérer des
espaces avec la touche Insérer. Supprimer des caractères en appuyant sur la touche Suppr.
En saisissant un texte, le contenu existant est écrasé sous la forme d’une chaı̂ne de car-
actères.
En saisissant des chiffres dans la vue d’HexEditor, les valeurs sont écrasées et l’aperçu est
mis à jour.
2.10 Recherche Incrémentale

Pour obtenir une recherche efficace dans des fichiers ouverts, Code::Blocks fourni ce qu’on
nomme une recherche incrémentale. Cette méthode de recherche s’initialise, pour un fichier
ouvert, via le menu ’Rechercher’ →’Recherche Incrémentale’ ou par le raccourci clavier
Ctrl-I. L’entrée active passe alors automatiquement à la configuration du masque de
recherche dans la barre d’outils correspondante. Dès que vous commencez à entrer des
termes de recherche, le fond du masque de recherche s’ajuste en fonction des occurrences
des termes. Si un accord est trouvé dans l’éditeur actif, la position respective est marquée
en couleur. Par défaut l’accord courant est surligné en vert. Cette configuration peut être
changée dans ’Paramètres’ →’ Éditeur’ →’ Recherche Incrémentale’ (voir Figure 2.13 à la
page 56). En appuyant sur la touche Entrée la recherche saute à l’occurrence suivante de
la chaı̂ne de texte recherchée à l’intérieur du fichier. Avec Maj-Entrée, c’est l’occurrence
précédente qui est sélectionnée. Cette fonctionnalité n’est pas supportée par Scintilla si
la recherche incrémentale utilise des expressions régulières.
Code::Blocks 55
Code::Blocks V2.0.1 beta 2.10 Recherche Incrémentale
Si la chaı̂ne de caractère recherchée ne peut pas être trouvée dans le fichier courant, afin
d’indiquer que c’est ce qui se passe, le fond du masque de recherche est affiché en rouge.
Figure 2.13: Paramètres pour la Recherche Incrémentale
ESC Quitte le module de Recherche Incrémentale.

ALT-Suppr Efface l’entrée du champ de recherche incrémentale.
Les icônes de la barre d’outils de Recherche Incrémentale ont les significations suivantes :
Suppression du texte dans le masque de recherche de la barre d’outils de Recherche

Incrémentale.
Code::Blocks 56
Code::Blocks V2.0.1 beta 2.11 Extension NassiShneiderman
, Navigation dans les occurrences de chaı̂ne recherchée.
En cliquant sur ce bouton ce sont toutes les occurrences de la chaı̂ne recherchée qui
sont surlignées en couleur, pas seulement la première.
Activer cette option réduit le champ de recherche au passage de texte marqué dans
l’éditeur.
Cette option signifie que la recherche sera sensible à la casse (respect des majuscules
et minuscules).
Valider les expressions régulières dans le champ d’entrée de la recherche incrémentale.
Note :
Le paramétrage standard de cette barre d’outil peut être configuré
dans ’Paramètres’ →’Éditeur’ →’Recherche Incrémentale’ .
2.11 Extension NassiShneiderman

L’extension NassiShneiderman permet de créer des diagrammes de Nassi Shneiderman
depuis Code::Blocks ([,→NassiShneiderman]).
2.11.1 Création d’un diagramme

Vous avez deux possibilités pour créer un diagramme.
1. Pour créer un diagramme vide, sélectionnez les options de menu ’Fichier’ →’Nouveau’
→’Diagramme de Nassi Shneiderman’ .
2. La deuxième option consiste à créer un diagramme depuis le code source C/C++.
Dans une fenêtre de l’éditeur, sélectionnez une partie de code pour en créer un diagramme.
Par exemple le corps d’une fonction/méthode depuis l’accolade ouvrante jusqu’à l’accolade
fermante. Puis, via un clic droit sur la sélection, choisissez ’Nassi Shneiderman’ →’Créer
un diagramme’ (voir Figure 2.14 à la page 58).
Vous devriez obtenir un nouveau diagramme (voir Figure 2.15 à la page 58).
L’analyseur a quelques limitations:
Des commentaires ne peuvent pas être placés en fin de branche.
Depuis la définition d’une fonction, on ne peut analyser que le corps de la fonction,
pas la déclaration.
Bien sûr, vous en trouverez bien d’autres...
Code::Blocks 57
Code::Blocks V2.0.1 beta 2.11 Extension NassiShneiderman
Figure 2.14: NassiShneiderman Création
Figure 2.15: NassiShneiderman Exemple de Diagramme
Code::Blocks 58
Code::Blocks V2.0.1 beta 2.12 LibFinder
2.11.2 Édition de structogrammes

2.11.2.1 Que faire avec un diagramme ?
Vous pouvez faire plein de choses avec un structogramme :

1. L’enregistrer pour l’utiliser plus tard. On peut l’enregistrer via ’Fichier’ →’Enregistrer
le fichier’ ou ’Fichier’ →’Enregistrer le fichier sous...’ .
2. On peut l’exporter dans différents formats ’Fichier’ →’Exporter’
”Exporter la source...” pour l’enregistrer comme fichier source en C.
”StrukTeX” pour l’utiliser dans une documentation sous LaTeX.
”PNG” ou ”PS” et éventuellement ”SVG” pour obtenir le diagramme dans un
format image connu de nombreux autres outils.
3. Insérer directement le code dans l’éditeur : Ouvrir ou créer un diagramme. De re-
tour dans la fenêtre d’édition, faites un clic droit et choisissez ’Nassi Shneiderman’
→’insérer en xy’ (Vous obtenez ici une liste de tous les diagrammes ouverts).
4. Glisser/Déposer le diagramme (ou une partie) dans d’autres outils. Par exemple
vers OpenOffice Writer afin d’y insérer une image dans votre documentation.
Si le diagramme choisi comporte une sélection, l’exportation ou la génération de code ne
portera que sur cette partie de diagramme.
2.11.2.2 Extensions
L’extension NassiShneiderman supporte quelques extensions des diagrammes de Nassi-

Shneiderman :
séparation d’une brique spécifique avec la ”flèche droite”
continuer sur une brique spécifique avec la ”flèche gauche”
Pour être en mesure de créer des diagrammes avec des instructions c/c++ ”switch”,
la sélection ne doit pas être implicitement interrompue avant un ”case”. Les différents
”cases” sont alignés verticalement. Support de C et C++.
2.12 LibFinder
Si vous voulez utilisez des librairies dans votre application, vous devez configurer votre
projet pour cela. Un tel processus de configuration peut être difficile et ennuyeux car
chaque librairie peut utiliser un schéma d’options particulier. Un autre problème est que
cette configuration diffère entre les plates-formes ce qui résulte en des incompatibilités
entre des projets Unix et Windows.
LibFinder propose deux fonctionnalités majeures :
Recherche des librairies installées sur votre système
Code::Blocks 59
Inclure les librairies dans votre projet en seulement quelques clics en rendant le
projet indépendant de la plate-forme
2.12.1 Recherche de librairies

La recherche des librairies est disponible via le menu ’Extensions’ →’Library finder’ . Son
but est de détecter les librairies installées sur votre système et d’enregistrer les résultats
dans la base de données de LibFinder (notez que ces résultats ne sont pas écrits dans les
fichiers projets de Code::Blocks). La recherche commence par un dialogue où vous pouvez
fournir un ensemble de répertoires où sont installées les librairies. LibFinder les analysera
de façon récursive aussi, si vous ne savez pas trop où elles sont, vous pouvez sélectionner
des répertoires génériques. Vous pouvez même entrer le disque complet – dans ce cas-là,
le processus de recherche prendra plus de temps mais il détectera davantage de librairies
(voir Figure 2.16 à la page 60).
Figure 2.16: Liste de répertoires
Quand LibFinder est à la recherche de librairies, il utilise des règles spéciales pour détecter
leur présence. Chaque ensemble de règle est situé dans un fichier xml. Actuellement
LibFinder peut rechercher wxWidgets 2.6/2.8, Code::Blocks SDK et GLFW – la liste
sera étendue dans le futur.
Note :
Pour obtenir davantage de détails sur comment ajouter un support
de librairie dans LibFinder, lisez dans les sources de Code::Blocks
src/plugins/contrib/lib finder/lib finder/readme.txt.
Après avoir terminé l’analyse, LibFinder affiche les résultats (voir Figure 2.17 à la page 61).
Dans la liste, vous cochez les librairies qui doivent être enregistrées dans la base de données
de LibFinder. Notez que chaque librairie peut avoir plus d’une configuration valide et les
Code::Blocks 60
Figure 2.17: Résultats de recherche
paramétrages ajoutés en premier sont plutôt destinés à être utilisés lors de la génération
de projets.
Au-dessous de la liste, vous pouvez sélectionner ce qu’il faut faire avec les résultats des
analyses précédentes :
Ne pas effacer les résultats précédents Cette option travaille comme une mise à jour
des résultats existants – Cela ajoute les nouveaux et met à jour ceux qui existent
déjà. Cette option n’est pas recommandée.
Seconde option (Effacer les résultats précédents des librairies sélectionnées) effacera
tous les résultats des recherches précédentes des librairies sélectionnées avant d’ajouter
les nouveaux résultats. C’est l’option recommandée.
Effacer toutes les configurations précédentes des librairies quand vous sélectionnez cette
option, la base de données de LibFinder sera effacée avant d’y ajouter les nouveaux
résultats. C’est utile quand vous voulez nettoyer une base de données LibFinder
contenant des résultats invalides.
Une autre option de ce dialogue est ’Configurer les Variables Globales’ . Quand vous
cochez cette option, LibFinder essaiera de configurer des Variables Globales qui sont
Code::Blocks 61
aussi utilisées pour aider à traiter les librairies.

Si vous avez pkg-config d’installé sur votre système (C’est installé automatiquement sur
la plupart des versions de systèmes linux) LibFinder proposera des librairies venant de
cet outil. Il n’est pas nécessaire de faire une analyse spécifique pour celles-ci – elles seront
automatiquement chargées au démarrage de Code::Blocks.
2.12.2 Inclure des librairies dans les projets

LibFinder ajoute un onglet supplémentaire dans les propriétés d’un projet ’Librairies’
– Cet onglet montre les librairies utilisées dans le projet ainsi que celles connues de
LibFinder. Pour ajouter une librairie dans votre projet, sélectionnez là dans le panneau
de droite et cliquez sur le bouton <. Pour enlever une librairie d’un projet, sélectionnez
la dans le panneau de gauche et cliquez sur le bouton > (voir Figure 2.18 à la page 62).
Figure 2.18: Configuration de projet
Vous pouvez filtrer les librairies connues de LibFinder en fournissant un filtre de recherche.
La case à cocher ’Afficher comme un arbre’ permet de basculer antre des vues sans
catégories et des vues avec catégories.
Si vous voulez ajouter une librairie qui n’est pas disponible dans la base de données de
LibFinder, vous pouvez utiliser le champ ’Librairie inconnue’ . Notez que vous devriez
entrer le ”library’s shortcode” (nom court, qui habituellement correspond au nom de
variable globale) ou le nom de librairie dans pkg-config. Vous trouverez une liste de noms
courts suggérés dans le Wiki de Code::Blocks dans Global Variables. L’usage de cette
option n’est recommandé que lorsqu’on prépare un projet qui doit être généré sur d’autres
machines où ce type de librairie existe et y est correctement détectée par LibFinder. Vous
pouvez accéder à une variable globale dans Code::Blocks comme :
Code::Blocks 62
Code::Blocks V2.0.1 beta 2.13 Extension SpellChecker
$ (#GLOBAL VAR NAME. i n c l u d e )
Cocher l’option ’Ne pas configurer automatiquement’ indiquera à LibFinder qu’il ne

devrait pas ajouter automatiquement les librairies lors de la compilation. Dans ce cas,
LibFinder peut s’invoquer depuis un script de génération. Un exemple d’un tel script est
généré et ajouté au projet en appuyant sur ’Ajouter un script de génération manuel’ .
2.12.3 Utilisation de LibFinder dans des projets générés par des

assistants
Les assistants vont créer des projets qui n’utilisent pas LibFinder. Pour les intégrer avec
cette extension, vous devrez mettre à jour manuellement les options de génération du
projet. Ceci est facilement obtenu en enlevant tous les paramétrages spécifiques aux li-
brairies et en ajoutant les librairies au travers de l’onglet ’Librairies’ dans les propriétés
du projet.
De tels projets deviennent indépendants des plates-formes. Tant que les librairies utilisées
sont dans la base de données de LibFinder, les options de génération du projet seront
automatiquement mises à jour pour coı̈ncider avec les paramétrages de librairie propres
aux plates-formes.
2.13 Extension SpellChecker

Une extension pour vérifier l’orthographe de chaı̂nes de caractères et de commentaires.
2.13.1 Introduction
Une extension pour vérifier l’orthographe de chaı̂nes de caractères et de commentaires.
L’orthographe est vérifiée au cours de la frappe. De plus un thésaurus est fourni. Les deux
peuvent être accédés sur demande en sélectionnant le mot en question, puis choisir entre
le correcteur... ou le Thesaurus... depuis le menu d’Édition (l’opération peut être affectée
à une touche d’accès rapide via le plugin Raccourcis Clavier). Le menu de contexte (clic
droit sur le mot) permet d’accéder aux suggestions d’orthographe.
2.13.2 Configuration
La configuration est dans le menu ’Paramêtres’ →’Éditeur’ . L’option ”spell check” est à
peu près à mi-chemin vers le bas de la liste de gauche.
La signification des différents contrôles est la suivante :
Activer spell checker en-ligne Active ou désactive spell checker.
Langue La langue utilisée pour la vérification orthographique et le thésaurus est sélectionnée
en choisissant un dictionnaire. On peut aussi le changer dans la barre d’état.
Configuration des chemins, Dictionnaires Le plugin cherche les fichiers dictionnaires
via ce chemin.
Code::Blocks 63
Figure 2.19: Configuration de SpellChecker
Configuration des chemins, Thésaurus Le plugin cherche les fichiers thésaurus via ce
chemin.
Configuration des chemins, Bitmaps (Optionnel) Le plugin cherche, via ce chemin, les
drapeaux à afficher dans la barre d’état.
Note :
Vous pouvez utiliser des Macros dans les trois con-
figurations de chemins, comme par ex. $(CODE-
BLOCKS)/share/codeblocks/SpellChecker. Voir Expansion de
Variables pour plus de détails. Ceci est pratique si vous utilisez une
version portable de Code::Blocks.
2.13.3 Dictionnaires
SpellChecker utilise une librairie nommée hunspell. Hunspell est le correcteur orthographique
de OpenOffice.org, Mozilla Firefox et d’autres projets. Les dictionnaires disponibles pour
ces applications sont compatibles avec ce plugin.
Open Office fourni toute une collection de dictionnaires pour plusieurs langues et dialectes
à télécharger. Les extensions de OOo 3.x (*.oxt) sont des archives compressés qui peuvent
être ouvertes avec votre logiciel d’archives préféré (par exemple 7-Zip ou File Roller).
Copiez le fichier .aff et le fichier .dic dans le répertoire configuré dans ’Configuration des
chemins, Dictionnaires’ (voir ci-dessus).
Si vous êtes sous Linux vous avez sans doute déjà des dictionnaires compatibles d’installés.
Code::Blocks 64
Regardez dans /usr/share/hunspell ou plutôt mon choix dans /usr/share/myspell/dicts.

La raison pour laquelle j’aime les fichiers myspell est qu’ils incluent d’office les fichiers
thésaurus qui sont correctement nommés pour travailler avec l’extension, et tout est placé
au même endroit. Ne copiez pas ces fichiers. Pointez seulement spell checker vers l’endroit
où ils se trouvent déjà.
Je sais que sous Windows, Firefox et Thunderbird installent aussi des fichiers dictionnaires
compatibles. On peut les trouver dans... C:\Program Files\Mozilla Firefox\dictionaries
ou C:\Program Files\Mozilla Thunderbird\dictionaries. De plus, OpenOffice.org
et LibreOffice installent aussi des fichiers dictionnaires dans
C:\Program Files\(Open/Libre)Office\share\extensions\dict-*.
Le navigateur Google Chrome installe aussi des dictionnaires, mais ils sont au format .bdic
et le plugin de correction orthographique de Code::Blocks ne peut pas travailler avec ces
fichiers.
2.13.4 Fichiers Thésaurus

Les fichiers de thésaurus sont aussi disponibles sur OOo, comme les dictionnaires. Copiez
les fichiers de thésaurus (th *.dat and th *.idx) dans le répertoire configuré dans ’Con-
figuration des chemins, Thésaurus’ (voir ci-dessus) puis renommez les pour que leur nom
concorde avec celui des dictionnaires mais les faire précéder de ”th ” tout en gardant
l’extension telle qu’elle est.
Exemple: Si les fichiers dictionnaires (pour moi, une seule langue) sont ”en GB.aff” et
”en GB.dic” les fichiers utilisés pour le thésaurus sont ”th en GB.idx” et ”th en GB.dat”.
Sur mon système Linux je trouve les fichiers thésaurus déjà installés dans /usr/share/myspel-
l/dicts et /usr/share/mythes. De même, ne déplacez pas les fichiers. Configurez spell
checker pour utiliser directement ces fichiers là où ils sont.
Sous Windows, si soit OpenOffice.org soit LibreOffice est installé, ils incluent souvent les
fichiers thésaurus dans C:\Program Files\(Open/Libre)Office\share\extensions\dict-*.
2.13.5 Bitmaps (Drapeaux)

L’image bitmap de la langue sélectionnée est affichée dans la barre d’état. S’il n’y a
pas d’image bitmap, c’est le nom de la langue qui s’affiche. L’image bitmap doit être au
format PNG Choisissez un drapeau dans famfamfam flag icons, copiez le dans le répertoire
configuré dans ’Configuration des chemins, Bitmaps’ (voir ci-dessus) et renommez-le pour
que le nom soit conforme à celui du dictionnaire mais gardez l’extension png.
2.13.6 Styles à vérifier

Seul du texte possédant un style spécifique peut être vérifié (par exemple seulement des
commentaires et des chaı̂nes de caractères). Les styles sont configurés automatiquement
par Scintilla (le composant d’édition de Code::Blocks).
Le fichier OnlineSpellChecking.xml contient une liste avec des indices sur les styles à
vérifier. Les indices ne sont pas les mêmes en fonction des langages de programma-
tion, et donc, le fichier contient une liste pour chacun des langages de programmation.
Code::Blocks 65
Code::Blocks V2.0.1 beta 2.14 Exporter du code Source
Pour ajouter des styles, regardez le nom du langage de programmation et les indices
dans le fichier correspondant lexer *.xml puis ajoutez cette information au fichier Online-
SpellChecking.xml.
Par exemple, pour vérifier l’orthographe dans des scripts de commande bash (fichiers
*.sh), ajoutez la ligne :
<Language name="Bash"index="2,5,6"/>
2.14 Exporter du code Source

Il est souvent nécessaire de transférer du code source vers d’autres applications ou vers
des e-mails. Si le texte est simplement copié, le formatage est perdu, ce qui rend le texte
peu clair. La fonction exporter de Code::Blocks est une des solutions dans ce type de
situations. Le format requis pour le fichier exporté peut être sélectionné via ’Fichier’
→’Exporter’ . Le programme adoptera alors le nom de fichier et le répertoire cible en
fonction du fichier source ouvert et les proposera pour enregistrer le fichier à exporter.
L’extension de fichier appropriée à chaque cas de figure sera déterminée par le type de
l’exportation. Les formats suivants sont disponibles :
html Un format de type texte qui peut être affiché dans un navigateur web ou dans un
traitement de texte.
rtf Le format Rich Text qui est un format basé sur du texte et qui peut être ouvert dans
un traitement de texte comme Word ou OpenOffice.
odt Le format Open Document Text qui est un format standardisé spécifié par Sun et
O’Reilly. Ce format peut être traité par Word, OpenOffice et d’autres traitements
de texte.
pdf Le format Portable Document qui peut être ouvert par des applications comme Ac-
robat Reader.
2.15 Support de SVN

Note :
NdT : Cette extension est traduite ici, mais est obsolète. Vous avez
donc de grandes chances de ne plus la trouver dans les versions
récentes de Code::Blocks.
Le support du système de contrôle de version SVN est inclus dans l’extension Code::Blocks
TortoiseSVN. Via le menu ’TortoiseSVN’ →’Plugin settings’ vous pouvez configurer les
commandes svn accessibles dans l’onglet ’Integration’ .
Menu intégration Ajoute une entrée TortoiseSVN dans la barre de menu avec différents
paramétrages.
Project manager Active les commandes TortoiseSVN du menu de contexte de la gestion
de projet.
Code::Blocks 66
Code::Blocks V2.0.1 beta 2.16 Liste des ”à faire”
Editor Active les commandes TortoiseSVN du menu de contexte de l’éditeur.

Dans la configuration de l’extension vous pouvez choisir quelles sont les commandes svn
qui sont accessibles dans le menu principal ou le menu de contexte. L’onglet intégration
fournit une entrée ’Edit main menu’ et ’Edit popup menu’ pour paramétrer ces com-
mandes.
Note :
L’Explorateur de fichiers dans Code::Blocks utilise différentes icônes
superposées afin d’indiquer l’état de svn. Les commandes de Tortois-
eSVN sont incluses dans le menu de contexte.
2.16 Liste des ”à faire”

Dans des projets logiciels complexes, où différents développeurs sont impliqués, il est
souvent nécessaire que différentes tâches soient effectuées par plusieurs utilisateurs. Pour
cela, Code::Blocks possède une Liste des ”à faire”. Cette liste s’ouvre via ’Vue’ →’Liste
des ”A faire”’ , et contient les tâches à effectuer ensemble, avec leurs priorités, le type et
le responsable de la tâche. On peut filtrer la liste par tâches, utilisateurs et/ou fichiers
sources. Un tri par colonnes peut être effectué en cliquant sur le titre de la colonne
correspondante.
Figure 2.20: Affichage de la Liste des ”A faire”
Note :
La liste des ”à faire” peut être ajoutée à la console de messages.
Sélectionnez l’option ’Inclure la liste des ”A faire” dans le panneau
de messages’ à l’aide du menu ’Paramètres’ →’Environnement’ .
Si les fichiers sources sont ouverts dans Code::Blocks, un ”à faire” peut être ajouté à la liste
via la commande ’Ajouter un élément ”à faire”’ du menu de contexte. Un commentaire
est ajouté dans le code sur la ligne sélectionnée.
// TODO ( u s e r #1#): a j o u t e r un nouveau d i a l o g u e pour l a p r o c h a i n e r e l e a s e
Quand on ajoute un ”à faire”, une boı̂te de dialogue apparaı̂t où les paramétrages suivants
peuvent être faits (voir Figure 2.21 à la page 68).
Code::Blocks 67
Code::Blocks V2.0.1 beta 2.17 Tools+
Figure 2.21: Dialogue pour ajouter un ”à faire”
Utilisateur Nom de l’utilisateur <user> pour le système d’exploitation. Les tâches pour
d’autres utilisateurs peuvent également être créées ici. Pour cela, le nom de l’utilisateur
correspondant doit être créé par Ajouter un nouvel utilisateur. L’assignation d’un
”à faire” est alors faite via une sélection d’entrées pour cet utilisateur.
Note :
Notez que les Utilisateurs ici n’ont rien à voir avec les profils (ou
personnalités) utilisés dans Code::Blocks.
Type Par défaut, le type est TODO (à faire”).

Priorité Dans Code::Blocks, l’importance de la tâche peut être exprimée par des priorités
(1 - 9).
Position Ce paramètre spécifie si le commentaire doit être inclus avant, après ou bien à
la position exacte du curseur.
Style de commentaire Une sélection de formats de commentaires (notamment doxygen).
2.17 Tools+
Créer un nouvel outil est assez facile, et cela peut s’effectuer en quelques étapes simples.
D’abord ouvrir ’Tools(+)’ →’Configurer les outils...’ pour accéder au dialogue des Outils
définis par l’utilisateur.
Code::Blocks 68
Figure 2.22: Dialogue des Outils définis par l’utilisateur
Nom de l’outil
C’est le nom qui sera affiché dans le menu déroulant de Tools(+). Il sera aussi affiché
comme nom d’onglet pour les Tools+ redirigés vers la fenêtre Outils.
Ligne de Commande
Toute ligne de commande valide, fonction et paramètres, peut être entrée ici. La substi-
tution de variable est également acceptée. La liste suivante contient les variables les plus
utiles (voir section 3.2 à la page 83 pour la liste complète).
$relfile, $file Respectivement, le nom relatif et absolu d’un fichier sélectionné.
$reldir, $dir Respectivement, le nom relatif et absolu d’un répertoire sélectionné.
$relpath, $path Le nom relatif et absolu d’un fichier ou répertoire sélectionné.
$mpaths Une liste de fichiers ou de répertoires sélectionnés (seulement des chemins
en absolu).
$fname, $fext Le nom sans extension et l’extension sans le nom d’un fichier sélectionné.
$inputstr{prompt}
Demande à l’utilisateur d’entrer une chaı̂ne de texte qui sera substituée
dans la ligne de commande.
$if(condition){true clause}{false clause}
Résolution en false clause si la condition est vide, 0, ou fausse; sinon
true clause .
Types de fichiers
Les expressions avec un caractère joker (*) séparées par des points virgules vont restrein-
dre le choix par le sous-menu clic droit sur un fichier, répertoire, chemin multiple dans
l’arborescence des projets, de l’explorateur de fichiers, ou du panneau d’éditeur à un/des
Code::Blocks 69
type/s spécifiés. Laisser vide pour traiter tous les types de fichiers/répertoires.
Répertoire de Travail
Le répertoire sur lequel exécuter la commande. Les variables de Code::Blocks, les variables
de projet, et les variables globales sont disponibles. De même,
1. Si $dir est entré dans la ligne de commande, alors $dir peut aussi être utilisé ici.
2. $parentdir est disponible pour $relle , $le , $reldir , $dir , $relpath, $path, $fname,
$fext , pour l’évaluation du chemin absolu d’un répertoire contenant cet élément.
Chemin du Menu Outils
Contrôle l’emplacement de la commande dans le menu de Tools(+), donnant la possibilité
d’ajouter des sous-menus (les niveaux multiples sont autorisés).
Submenu/Tool1
Submenu/Tool2
Tool3
Va créer cette structure.
Figure 2.23: Structure des menus de Tools
Le nom de la commande sera utilisé si cette entrée est vide. Si le premier caractère est un
point, la commande sera cachée.
Chemin du Menu de Contexte
Ceci contrôle l’emplacement de la commande dans le menu clic-droit des Projets et des
onglets de fichiers du panneau de Gestion. Les mêmes règles que pour la structure des
menu de Tools+ s’appliquent ici.
Code::Blocks 70
Figure 2.24: Structure des menus de Contexte
Notez SVP que la commande n’apparaı̂tra dans les menus de contexte que si la ligne de
commande contient un ou plusieurs des éléments suivants : $relle , $le , $reldir , $dir ,
$relpath, $path, $fname, et $fext .
Sortie vers
Ceci détermine vers où la sortie de la commande sera redirigée. Le but et la fonction de
la commande détermineront ce qui est le mieux à faire. Tools Output Window
Les outils qui ne requièrent que des résultats de sortie en ligne de commande (et ne
demandent pas d’entrées) utilisent généralement cette façon de faire. Le programme sera
lancé en mode invisible et toutes les sorties seront redirigées vers l’onglet approprié de
la fenêtre de sortie des Outils Tools+. Le texte [DONE/TERMINÉ] sera ajouté en fin
d’exécution de l’Outil.
Code::Blocks 71
Figure 2.25: Fenêtre de sortie de l’Outil
Note :
Si la fenêtre de sortie des Outils Tools+ est ouverte à la clôture de
Code::Blocks, il se peut que Code::Blocks plante.
Console de Code::Blocks
Ceci va permettre de lancer le programme via l’exécutable cb console runner (ce même
programme qui est lancé après Générer et exécuter). Généralement, c’est utilisé par les
outils en ligne de commande pour obtenir des interactions utilisateur avancées, bien que
des programmes graphiques puissent aussi être utilisés (notamment si le programme n’est
pas stable ou s’il affiche des messages dans la sortie standard). Le ”Console runner” mettra
la fenêtre en pause (l’empêchant de se fermer), affichera le temps d’exécution, ainsi que
le code de sortie quand le programme s’arrêtera.
Shell Standard
C’est la même chose que de placer cette commande dans un script batch ou un script
Shell puis de l’exécuter. Le programme s’exécutera quelle que soit la méthode par défaut,
et lorsqu’il aura terminé, sa fenêtre se fermera.. Ce paramètre est utile pour exécuter un
programme (par exemple un fichier ou un navigateur Web) qui doit rester ouvert après la
fermeture de Code::Blocks.
Note :
Comme le plugin Tools+ plugin est en cours de développement,
quelques fonctionnalités - par exemple Priorité de Menu et Variables
d’environnement - peuvent ne pas être disponibles.
2.17.1 Exemple d’Outils Tools+

Ouvrir l’explorateur sur un fichier sélectionné
Windows Explorer
– Menu Outils Tools+
explorer /select,"$(PROJECTFILE)"
Code::Blocks 72
– Menu de Contexte
explorer /select,"$path"
Dolphin
dolphin --select "$(PROJECTFILE)"
dolphin --select "$path"
Note :
Les trois commandes suivantes du menu contextuel ne prennent en
charge que les dossiers (mais pas les fichiers).
Nautilus
nautilus --no-desktop --browser "$(PROJECTDIR)"
nautilus --no-desktop --browser "$dir"
Thunar
thunar "$(PROJECTDIR)"
thunar "$dir"
PCMan File Manager
pcmanfm "$(PROJECTDIR)"
pcmanfm "$dir"
Mise à jour d’un répertoire Subversion
Windows
– Menus Outils Tools+
"path_to_svn\bin\svn" update "$inputstr{Directory}"
Code::Blocks 73
"path_to_svn\bin\svn" update "$dir"

Linux
– Menus Outil Tools+
svn update "$inputstr{Directory}"
svn update "$dir"
Exporter un makefile
Note :
Utilisation de l’outil en ligne de commande cbp2make.
Windows
"path_to_cbp2make\cbp2make" -in "$(PROJECTFILE)"
Linux
"path_to_cbp2make/cbp2make" -in "$(PROJECTFILE)"
Compresser le projet actif dans une archive
Windows
– 7z ou zip - Menus Outil Tools+ (sur 1 seule ligne)
"path_to_7z\7z" a -t$if(zip == $inputstr{7z or zip?}){zip -mm=Deflate
-mmt=on -mx9 -mfb=128 -mpass=10}{7z -m0=LZMA -mx9
-md=64m -mfb=64 -ms=on} -sccUTF-8 "-w$(PROJECTDIR).."
"$(PROJECTDIR)..\$(PROJECT_NAME)" "$(PROJECTDIR)*"
– tar.gz ou tar.bz2 - Menus Outil Tools+ (sur 1 seule ligne)
cmd /c ""path_to_7z\7z" a -ttar -mx0 -sccUTF-8 "-w$(PROJECTDIR).."
"$(PROJECTDIR)..\$(PROJECT_NAME)" "$(PROJECTDIR)*" &&
"path_to_7z\7z" a -t$if(gz == $inputstr{gz or bz2?}){gzip -mx9
-mfb=128 -mpass=10 -sccUTF-8 "-w$(PROJECTDIR).."
"$(PROJECTDIR)..\$(PROJECT_NAME).tar.gz}{bzip2 -mmt=on -mx9
-md=900k -mpass=7 -sccUTF-8 "-w$(PROJECTDIR).."
"$(PROJECTDIR)..\$(PROJECT_NAME).tar.bz2}"
"$(PROJECTDIR)..\$(PROJECT_NAME).tar" &&
cmd /c del "$(PROJECTDIR)..\$(PROJECT_NAME).tar""
Code::Blocks 74
Code::Blocks V2.0.1 beta 2.18 Thread Search
Note :
L’interpréteur en ligne de commande de Windows a été invoqué di-
rectement ici (cmd /c), ce qui permet à des commandes multiples de
s’enchaı̂ner en une seule ligne. Cependant, cela peut provoquer un
échec de l’exécution de la commande dans la console Code::Blocks.
Linux
– 7z ou zip - Menu Outils Tools+ (sur 1 seule ligne)
7z a -t$if(zip == $inputstr{7z or zip?}){zip -mm=Deflate -mmt=on -mx9
-mfb=128 -mpass=10}{7z -m0=LZMA -mx9 -md=64m -mfb=64 -ms=on}
-sccUTF-8 "-w$(PROJECTDIR).." "$(PROJECTDIR)../$(PROJECT_NAME)"
"$(PROJECTDIR)*"
– tar.gz ou tar.bz2 - Menu Outils Tools+ (sur 1 seule ligne)
tar -cf "$(PROJECTDIR)../$(PROJECT_NAME).tar.$if(gz == $inputstr{gz
ou bz2?}){gz" -I ’gzip}{bz2" -I ’bzip2} -9’ "$(PROJECTDIR)*"
2.18 Thread Search

Via le menu ’Rechercher’ →’Thread Search’ , cette extension peut être affichée ou masquée
en tant qu’onglet dans la console de messages. Dans Code::Blocks, une prévisualisation
de l’occurrence de la chaı̂ne de caractères peut être affichée pour un fichier, un espace de
travail ou un répertoire. Ce faisant, la liste des résultats de la recherche sera affichée sur
la partie droite de la console ThreadSearch. En cliquant sur une entrée de la liste, une
prévisualisation s’affiche sur la partie gauche. En double-cliquant dans la liste, le fichier
sélectionné est ouvert dans l’éditeur de Code::Blocks.
Note :
L’étendue des extensions de fichiers à inclure dans la recherche est
préconfiguré et peut avoir besoin d’être ajusté.
L’extension ThreadSearch offre les fonctionnalités suivantes :
’Recherche dans les fichiers’ multi tâches (Multi-threaded).
Éditeur interne en lecture seule pour voir les résultats
Fichier ouvert dans l’éditeur de type notebook
Menu contextuel ’Rechercher les occurrences’ pour commencer une recherche dans
les fichiers à partir du mot situé sous le curseur
Code::Blocks 75
Figure 2.26: Panneau de Thread Search
2.18.2 Utilisation
1. Configurez vos préférences de recherche (voir Figure 2.27 à la page 77)
Une fois l’extension installée, il y a 4 façons de conduire une recherche :
a) Tapez/Sélectionnez un mot dans la boı̂te de recherche combinée et appuyez
sur Entrée ou cliquez sur Rechercher dans le panneau de Thread search de la
console de messages.
b) Tapez/Sélectionnez un mot dans la boı̂te de recherche combinée de la barre
d’outil et appuyez sur Entrée ou cliquez sur le bouton Rechercher.
c) Clic droit sur n’importe quel ’mot’ dans l’éditeur actif puis cliquez sur ’Rechercher
les occurrences’.
d) Cliquez sur Rechercher/Thread search pour trouver le mot courant dans l’éditeur
actif.
Note :
Les points 1, 2 et 3 peuvent ne pas être disponibles en fonction de la
configuration courante.
2. Cliquez de nouveau sur le bouton de recherche pour arrêter la recherche en cours.
3. Un clic simple sur un élément résultat l’affiche dans la prévisualisation sur la droite.
4. Un double-clic sur un élément résultat ouvre ou configure un éditeur sur la droite.
2.18.3 Configuration
Pour accéder au panneau de configuration de l’extension ThreadSearch cliquez sur (voir
Figure 2.27 à la page 77) :
1. Bouton des Options du panneau de Thread search dans la console des messages.
2. Bouton des Options dans la barre d’outils de Thread search.
3. Menu Paramètres/Environnement puis choisir l’élément Thread search dans la colonne
de gauche.
Code::Blocks 76
Figure 2.27: Configuration de Thread Search
Note :
Les points 1, 2 et 3 peuvent ne pas être disponibles en fonction de la
configuration courante.
La recherche partielle défini l’ensemble de fichiers qui seront analysés.

Les cases à cocher Projet et Espace de travail sont mutuellement exclusives.
Le chemin du répertoire peut être édité ou configuré via le bouton Sélection.
Masque est l’ensemble des spécifications de fichiers séparées par des ’;’. Par exemple:
*.cpp;*.c;*.h.
2.18.4 Options
Mot entier si coché, lignes contenant l’expression recherchée si l’expression recherchée
est trouvée sans caractères alphanumériques +'_' avant et après.
Début de mot si coché, lignes contenant l’expression recherchée si l’expression recherchée
est trouvée au début d’un mot sans caractères alphanumériques +'_' avant et après.
Respecter la casse si coché, la recherche est sensible à la casse (majuscules-minuscules).
Expression régulière l’expression recherchée est une expression régulière.
Code::Blocks 77
Note :
Si vous voulez chercher des expressions régulières comme \n vous
devrez choisir l’option ’Utiliser des recherches RegEx avancées’ via
le menu ’Paramètres’ →’Éditeur’ →’Paramètres généraux’ .
2.18.5 Options de Thread search (ou Tâche de Recherche)

Activer les éléments du menu contextuel ’Trouver les occurrences’ Si coché, l’entrée
Trouver les occurrences est ajoutée au menu contextuel de l’éditeur.
Utiliser les options par défaut du menu ’Trouver les occurrences’ Si coché, un ensem-
ble d’options par défaut est appliqué aux recherches lancées par ’Trouver les occur-
rences’ du menu de contexte correspondant. Par défaut l’option ’Mot entier’ et
’Respecter la casse’ est activé.
Effacer les résultats précédents en début de recherche Si l’extension ThreadSearch est
configurée en ’Vue arborescente’ alors les résultats de la recherche sont listés dans
l’ordre hiérarchique suivant,
le premier noeud contient le terme cherché
ensuite les fichiers qui contiennent ce terme sont listés
dans cette liste les numéros des lignes et le contenu correspondant sont affichés
Si vous recherchez plusieurs termes, la liste deviendra confuse, aussi les résultats des
recherches précédents peuvent être supprimés en utilisant cette option en début de
recherche.
Note :
Dans la liste des occurrences les termes seuls ou tous les termes peu-
vent être supprimés via le menu de contexte ’Supprimer l’élément’ ou
’Supprimer tous les éléments’ .
2.18.6 Mise en page

Afficher l’en-tête dans la fenêtre de logs si coché, l’en-tête est affiché dans la liste des
résultats de contrôle.
Note :
Si non coché, les colonnes ne sont plus redimensionnables mais on
économise de la place.
Dessiner des lignes entre les colonnes Dessine des lignes entre les colonnes en mode
Liste.
Afficher la barre d’outils de ThreadSearch Afficher la barre d’outils de l’extension Thread-
Search.
Afficher les widgets de recherche dans le panneau de messages de ThreadSearch Si
coché, seuls les résultats de la liste de contrôle et l’éditeur de prévisualisation sont
affichés. Les autres widgets de recherches sont masqués (économise de la place).
Code::Blocks 78
Code::Blocks V2.0.1 beta 2.19 Code statistics
Afficher l’éditeur de prévisualisation de code La prévisualisation du code peut être masquée

soit par cette case à cocher soit par un double-clic sur la bordure du séparateur en
milieu de fenêtre. C’est ici qu’on peut le faire de nouveau s’afficher.
2.18.7 Panneau de Gestion

Vous pouvez choisir différents modes de gestion de la fenêtre de ThreadSearch. Avec
le choix ’Panneau de Messages’ la fenêtre ThreadSearch sera intégrée à la console de
messages dans un des onglets. Si vous choisissez ’Mise en page’ vous pourrez le détacher
de la console et obtenir une fenêtre flottante que vous pourrez placer ailleurs.
2.18.8 Type de journal

La vue des résultats de recherche peut s’afficher de plusieurs façons. Le choix ’Liste’ affiche
toutes les occurrences sous forme d’une liste. L’autre mode ’Arborescence’ assemble toutes
les occurrences internes d’un fichier dans un noeud.
2.18.9 Mode de partage de fenêtre

L’utilisateur peut configurer la séparation de fenêtre de prévisualisation et de sortie des
résultats de recherche horizontalement ou verticalement.
2.18.10 Tri des résultats de recherche

Les résultats de recherche peuvent être triés par le nom de chemin ou le nom de fichier.
2.19 Code statistics
Figure 2.28: Configuration de Code Statistics
Basée sur les caractéristiques d’un masque de configuration, cette simple extension détecte
les pourcentages de codes, commentaires et lignes blanches d’un projet. L’évaluation se
lance via la commande de menu ’Extensions’ →’Code statistics’ .
2.20 Profilage de Code

Une interface graphique simple au Profileur GNU GProf.
Code::Blocks 79
Code::Blocks V2.0.1 beta 2.21 Importation de Projets
2.21 Importation de Projets

Le plugin ProjectsImporter importe des projets et des espaces de travail d’autres IDE,
notamment Dev-C++, MSVC6, MSVC7, et MSVC8 pour les utiliser comme projets
Code::Blocks.
2.22 Recherche de Code Source Disponible

Cette extension permet de sélectionner un terme dans l’éditeur et de rechercher ce terme
à l’aide du menu de contexte ’Rechercher dans Koders’ dans la base de données du
site [?]. La boı̂te de dialogue permet d’ajouter la possibilité de filtrer les langages de
programmation ou le type de licence.
Note :
Koders et son successeur BlackDuck semblent avoir disparu ou changé
de site Web ! Aussi ce plugin ne fonctionne plus. En attente de mise
à jour ...
Cette recherche dans la base vous aidera à trouver du code source originaire du monde
entier en provenance d’autres projets universitaires, consortiums et d’organisations comme
Apache, Mozilla, Novell Forge, SourceForge et bien d’autres, qui peuvent être réutilisés
sans avoir à réinventer la roue à chaque fois. SVP, regardez bien la licence du code source
dans chaque cas particulier.
2.23 Extension Symbol Table

Cette extension permet de rechercher des symboles dans des fichiers objets et dans des
librairies. Les options et le chemin d’accès au programme nm en ligne de commande sont
définis dans l’onglet des Options.
Cliquer sur ’Rechercher’ démarre la recherche. Les résultats du programme NM sont alors
affichés dans une fenêtre séparée nommée ’SymTabs Result’. Les noms des fichiers objets
et des librairies contenant les symboles sont listés avec comme titre ’Sortie de NM’.
Code::Blocks 80
Code::Blocks V2.0.1 beta 2.23 Extension Symbol Table
Figure 2.29: Configuration de Symbol Table
Code::Blocks 81
3 Expansion de Variables
Code::Blocks fait la différence entre plusieurs types de variables. Ces types peuvent servir à
configurer l’environnement de création d’un programme, mais aussi à accroı̂tre la mainten-
abilité et la portabilité. L’accès aux variables de Code::Blocks s’obtient grâce à $<name>.
Variables d’Environnement sont configurées au démarrage de Code::Blocks. Elles peu-
vent modifier les variables d’environnement du système telles que PATH. Cela peut
être utile dans les cas où une variable d’environnement spécifique est nécessaire à la
création de projets. La configuration des variables d’environnement dans Code::Blocks
se fait à l’aide de ’Paramètres’ →’Environnement’ →’Variables d’environnement’ .
Variables internes sont prédéfinies dans Code::Blocks, et peuvent être accédées via leurs
noms (voir les détails dans section 3.2 à la page 83).
Macros Commandes Ce type de variables est utilisé pour contrôler le processus de
génération. Pour de plus amples informations se référer à section 3.4 à la page 88.
Variables Utilisateur sont des variables définies par l’utilisateur qui peuvent être spécifiées
dans les options de génération d’un projet. Ici vous pouvez, par exemple définir votre
type de processeur comme une variable MCU et lui assigner une valeur correspon-
dante. Puis entrer dans les options de compilation -mcpu=$(MCU), et Code::Blocks
le remplacera automatiquement par le contenu. Par cette méthode, la configuration
d’un projet peut être largement paramétrée.
Variables Globales sont surtout utilisées pour créer Code::Blocks à partir des sources ou
pour le développement d’applications wxWidgets. Ces variables ont une significa-
tion bien particulière. Par rapport à toutes les autres, si vous configurez de telles
variables et partagez votre fichier projet avec d’autres qui eux n’ont *pas* con-
figuré ces variables globales (ou GV), Code::Blocks demandera à l’utilisateur de
les configurer. C’est un moyen pratique de d’assurer qu’un ’autre développeur’ sait
facilement ce qu’il doit configurer. Code::Blocks posera la question pour tous les
chemins usuellement nécessaires.
3.1 Syntaxe
Code::Blocks traite de façon équivalente, en tant que variables, les séquences de caractères
suivantes dans les étapes de pré-génération, post-génération ou génération :
$VARIABLE
$(VARIABLE)
${VARIABLE}
%VARIABLE%
Les noms de variables doivent être composés de caractères alphanumériques et sont in-
sensibles à la casse (minuscules-majuscules). Les variables commençant par un seul signe
dièse (#) sont interprétées comme des variables utilisateur globales (voir les détails dans
Code::Blocks V2.0.1 beta 3.2 Liste des variables internes
la section 3.7 à la page 89). Les noms listés ci-dessous sont interprétés comme des types
de variables internes.
Les variables qui ne sont ni de type utilisateur globales ni de type interne, seront rem-
placées par une valeur fournie dans le fichier projet, ou par une variable d’environnement
si ce dernier échoue.
L’utilisation de ces variables peut être effectuée comme dans l’exemple suivant :
#include "include/manager.h"
wxString strdate = Manager::Get()=>GetMacrosManager()=>ReplaceMacros(_T("$TODAY"));
Note :
Les définitions ”par cible” sont prioritaires par rapport aux définitions
par-projet.
3.2 Liste des variables internes

Les variables listées ci-dessous sont des variables internes à Code::Blocks. Elles ne peuvent
pas être utilisées dans des fichiers sources.
3.2.1 Espace de travail Code::Blocks

$(WORKSPACE_FILENAME), $(WORKSPACE_FILE_NAME), $(WORKSPACEFILE), $(WORKSPACEFILENAME)
Le nom de fichier de l’espace de travail courant (.workspace).
$(WORKSPACENAME), $(WORKSPACE_NAME)
Le nom de l’espace de travail qui est affiché dans l’onglet Projets du
panneau Gestion.
$(WORKSPACE_DIR), $(WORKSPACE_DIRECTORY), $(WORKSPACEDIR), $(WORKSPACEDIRECTORY)
Le répertoire où se trouve l’espace de travail.
3.2.2 Fichiers et répertoires

$(PROJECT_FILENAME), $(PROJECT_FILE_NAME), $(PROJECT_FILE), $(PROJECTFILE)
Le nom de fichier du projet en cours de compilation.
$(PROJECT_NAME), $(PROJECTNAME)
Le nom du projet en cours de compilation.
$(PROJECT_DIR), $(PROJECTDIR), $(PROJECT_DIRECTORY)
Le répertoire commun de plus haut niveau du projet en cours de com-
pilation.
$(ACTIVE_EDITOR_FILENAME)
Le nom du fichier ouvert dans l’éditeur actif courant.
$(ACTIVE_EDITOR_LINE)
Retourne le numéro de ligne courant dans l’éditeur actif.
$(ACTIVE_EDITOR_COLUMN
Retourne le numéro de colonne courant dans l’éditeur actif.
Code::Blocks 83
$(ACTIVE_EDITOR_DIRNAME)
le répertoire contenant le fichier actif courant (relatif au chemin de
plus haut niveau).
$(ACTIVE_EDITOR_STEM)
Le nom de base (sans extension) du fichier actif courant.
$(ACTIVE_EDITOR_EXT)
L’extension du fichier actif courant.
$(ALL_PROJECT_FILES)
Une chaı̂ne contenant les noms de tous les fichiers du projet courant.
$(MAKEFILE) Le nom de fichier du makefile.
$(CODEBLOCKS), $(APP_PATH), $(APPPATH), $(APP-PATH)
Le chemin de l’instance courante de Code::Blocks en cours d’exécution.
$(DATAPATH), $(DATA_PATH), $(DATA-PATH)
Le répertoire ’partagé’ de l’instance courante de Code::Blocks en cours
d’exécution.
$(PLUGINS) Le répertoire des plugins (ou extensions) de l’instance courante de
Code::Blocks en cours d’exécution.
$(TARGET_COMPILER_DIR)
Le répertoire d’installation du compilateur appelé aussi chemin maı̂tre.
3.2.3 Cibles de génération

Remplacer FOOBAR par le nom de la cible
$(FOOBAR_OUTPUT_FILE)
Le fichier de sortie d’une cible spécifique.
$(FOOBAR_OUTPUT_DIR)
Le répertoire de sortie d’une cible spécifique.
$(FOOBAR_OUTPUT_BASENAME)
Le nom de base du fichier de sortie (sans chemin, sans extension) d’une
cible spécifique.
$(FOOBAR_PARAMETERS)
Les paramètres d’exécution d’un cible spécifique
$(TARGET_OUTPUT_DIR)
Le répertoire de sortie de la cible courante.
$(TARGET_OBJECT_DIR)
Le répertoire objet de la cible courante.
$(TARGET_NAME)
Le nom de la cible courante.
$(TARGET_OUTPUT_FILE)
Le fichier de sortie de la cible courante.
$(TARGET_OUTPUT_BASENAME)
Le nom de base du fichier de sortie (sans chemin, sans extension) de
la cible courante.
Code::Blocks 84
$(TARGET_CC), $(TARGET_CPP), $(TARGET_LD), $(TARGET_LIB)

L’outil de génération (compilateur, éditeur de liens, etc.) de la cible
courante.
$(TARGET_COMPILER_DIR)
Le répertoire courant des outils de génération (compilateur, éditeur de
liens, etc.).
3.2.4 Langue et encodage

$(LANGUAGE) La langue du système en clair.
$(ENCODING) L’encodage du système en clair.
3.2.5 Heure et date

$(TDAY) Date courante sous la forme AAAAMMJJ (par exemple 20051228)
$(TODAY) Date courante sous la forme AAAA-MM-JJ (par exemple 2005-12-28)
$(NOW) Heure courante sous la forme AAAA-MM-JJ-hh.mm (par exemple
2005-12-28-07.15)
$(NOW_L) Heure courante sous la forme AAAA-MM-JJ-hh.mm.ss (par exemple
2005-12-28-07.15.45)
$(WEEKDAY) Nom du jour de la semaine en clair (par exemple ’Mercredi’)
$(TDAY_UTC), $(TODAY_UTC), $(NOW_UTC), $(NOW_L_UTC), $(WEEKDAY_UTC)
Ces types sont identiques aux précédents mais exprimés en temps uni-
versel TU.
$(DAYCOUNT) Nombre de jours passés depuis une date arbitraire choisie comme orig-
ine (1er Janvier 2009). Utile comme dernier composant d’un numéro
de version/génération.
3.2.6 Dépendant de la Plateforme

$(PLATFORM) remplacé par msw sous windows et unix sous linux et mac (Depuis la
révision r11793)
3.2.7 Commandes du Système d’exploitation

La variable est remplacée par la commande effective du Système d’exploitation.
$(CMD_CP) Commande de Copie de fichiers.
$(CMD_RM) Commande de Suppression de fichiers.
$(CMD_MV) Commande de Déplacement de fichiers.
$(CMD_NULL) NULL device (pour rediriger un flux)
$(CMD_MKDIR) Commande de Création de répertoire.
$(CMD_RMDIR) Commande de Suppression de répertoire.
Code::Blocks 85
3.2.8 Valeurs aléatoires

$(COIN) Cette variable simule un pile ou face (à chaque invocation) et retourne
0 ou 1.
$(RANDOM) Un nombre positif aléatoire sur 16 bits (0-65535)
3.2.9 Chemins Standard

$(GET_DATA_DIR)
Unix: prefix/share/appname ; Windows: chemin EXE
$(GET_LOCAL_DATA_DIR)
Unix: /etc/appname ; Windows: chemin EXE
$(GET_CONFIG_DIR)
Unix: /etc ; Windows: C:\Documents and Settings\All Users\Application
Data
$(GET_USER_CONFIG_DIR)
Unix: ; Windows: C:\Documents and Settings\username\Application
Data\appname
$(GET_USER_DATA_DIR)
Unix: /.appname ; Windows: C:\Documents and Settings\username\Application
Data
$(GET_USER_LOCAL_DATA_DIR)
Unix: /.appname ; Windows: C:\Documents and Settings\username\Local
Settings\Application Data\appname
$(GET_TEMP_DIR)
TOUTES plateformes: Un répertoire temporaire accessible en écriture
3.2.10 Fonctions internes pour la conversion de chemins

Ce sont des fonctions macro pour simplifier la génération des chemins
$TO_UNIX_PATH{}
converti vers un chemin unix (utilise ’/’ comme séparateur)
$TO_WINDOWS_PATH{}
converti vers un chemin windows (utilise ’\’ comme séparateur)
$TO_NATIVE_PATH{}
converti vers le chemin natif de la plate-forme où l’instance de Code::Blocks
s’exécute
Utilisation
$TO_UNIX_PATH{$(TARGET_OUTPUT_FILE)}
retourne le fichier de sortie de la cible courante en tant que chemin
unix
Code::Blocks 86
Code::Blocks V2.0.1 beta 3.3 Expansion de script
3.2.11 Évaluation Conditionnelle

$ i f ( c o n d i t i o n ) { c l a u s e s i v r a i e }{ c l a u s e s i f a u s s e }
L’évaluation Conditionnelle sera considérée comme vraie dans les cas suivants
la condition est un caractère non vide autre que 0 ou false
la condition est une variable non vide qui ne se résout pas en 0 ou false
la condition est une variable qui est évaluée à true (implicite par une condition
précédente)
L’évaluation Conditionnelle sera considérée comme fausse dans les cas suivants
la condition est vide
la condition est 0 ou false
la condition est une variable qui est vide ou évaluée à 0 ou false
Note :
Notez SVP que les variantes de syntaxe de variable %if (...) ou
$( if )(...) ne sont pas supportées dans ce type de construction.
Exemple
Par exemple : vous utilisez plusieurs plateformes et vous voulez configurer différents
paramètres en fonction du système d’exploitation. Dans le code suivant, la commande
de script [[ ]] est évaluée et la <commande> sera exécutée. Ce peut être utile dans une
étape de post-génération.
[ [ i f (PLATFORM == PLATFORM MSW) { p r i n t ( T ( ”cmd / c ” ) ) ; } e l s e
{ p r i n t ( T ( ” sh ” ) ) ; } ] ] <commande>
3.3 Expansion de script

Pour une flexibilité maximale, vous pouvez imbriquer les scripts en utilisant l’opérateur
[[ ]] en tant que cas particulier d’expansion de variable. Les scripts imbriqués ont accès
à toutes les fonctionnalités standard disponibles pour les scripts et se comportent comme
des ”backticks” (ou apostrophes inversées) de bash (à l’exception de l’accès au namespace
de Code::Blocks). En tant que tels, les scripts ne sont pas limités à la production de sorties
de type texte, mais peuvent aussi manipuler des états de Code::Blocks (projets, cibles,
etc.).
Note :
La manipulation d’états de Code::Blocks devrait être implémentée
dans des étapes de pré-générations plutôt que dans un script.
Code::Blocks 87
Code::Blocks V2.0.1 beta 3.4 Macros Commandes
Exemple avec Backticks

objdump =D ‘ f i n d . =name * . e l f ‘ > name . d i s
L’expression entre ”backticks” (ou apostrophes inversées) retourne une liste de tous les
exécutables *.elf des sous-répertoires. Le résultat de cette expression peut être utilisé
directement par objdump. Au final, la sortie est redirigée vers un fichier nommé name.dis.
Ainsi, des processus peuvent être automatisés simplement sans avoir recours à aucune
boucle.
Exemple utilisant un Script
Le texte du script est remplacé par toute sortie générée par votre script, ou ignoré en cas
d’erreur de syntaxe.
Comme l’évaluation conditionnelle est exécutée avant l’expansion de scripts, l’évaluation
conditionnelle peut être utilisée pour les fonctionnalités de type pré-processeur. Les vari-
ables internes (et les variables utilisateur) sont étendues en sortie de scripts, aussi on peut
référencer des variables dans les sorties d’un script.
[ [ p r i n t ( GetProjectManager ( ) . G e t A c t i v e P r o j e c t ( ) . G e t T i t l e ( ) ) ; ]]
insère le titre du projet actif dans la ligne de commande.
3.4 Macros Commandes

$compiler Accède au nom de l’exécutable du compilateur.
$linker Accède au nom de l’exécutable de l’éditeur de liens.
$options Flags du Compilateur
$link_options Flags de l’éditeur de liens
$includes Chemins des include du compilateur
$c Chemins des include de l’éditeur de liens
$libs Librairies de l’éditeur de liens
$file Fichier source (nom complet)
$file_dir Répertoire du fichier source sans le nom de fichier ni son extension.
$file_name Nom du fichier source sans les informations de chemin ni l’extension.
$exe_dir Répertoire du fichier exécutable sans le nom de fichier ni son extension.
$exe_name Nom du fichier exécutable sans les informations de chemin ni l’extension.
$exe_ext Extension de l’exécutable sans les informations de chemin ni le nom
du fichier.
$object Fichier objet
Code::Blocks 88
Code::Blocks V2.0.1 beta 3.5 Compilation d’un fichier unique
$exe_output Fichier exécutable de sortie

$objects_output_dir
Répertoire de sortie des fichiers objets
3.5 Compilation d’un fichier unique

$ c o m p i l e r $ o p t i o n s $ i n c l u d e s =c $ f i l e =o $ o b j e c t
3.6 Édition de liens de fichiers objets en exécutable

$ l i n k e r $ l i b d i r s =o $ e x e o u t p u t $ l i n k o b j e c t s $ l i n k r e s o b j e c t s
$link options $libs
3.7 Variables globales du compilateur

Cette section décrit comment travailler avec des variables globales.
3.7.1 Synopsis
Travailler en tant que développeur sur un projet reposant sur des librairies tierces im-
pose un certain nombre de tâches répétitives inutiles, comme configurer des variables de
génération dépendantes du système de fichier local. Dans le cas de fichiers projets, une
attention toute particulière doit être apportée afin d’éviter de diffuser une copie modifiée
localement. Si on n’y prend pas garde, cela peut se produire facilement après avoir changé
par exemple un flag de génération pour obtenir une version de type release.
Le concept de variable globale du compilateur est une nouvelle solution unique à Code::Blocks
qui adresse ce problème. Les variables globales du compilateur vous permettent de con-
figurer un projet une seule fois, avec n’importe quel nombre de développeurs utilisant
n’importe quel système de fichiers pour compiler et développer ce projet. Aucune infor-
mation locale ne nécessite d’être changée plus d’une fois.
3.7.2 Noms et Membres

Les variables globales du compilateur dans Code::Blocks se distinguent des variables par-
projet par la présence d’un signe dièse en tête. Les variables globales du compilateur
sont structurées ; chaque variable consiste en un nom et un membre optionnel. Les noms
sont définissables librement, alors que les membres sont construits dans l’Environnement
Intégré de Développement (IDE). Bien que vous puissiez choisir n’importe quoi comme
nom en principe, il est recommandé de reproduire des identificateurs connus de packages
communément utilisés. Ainsi, le nombre d’informations que l’utilisateur doit fournir est
minimisé. L’équipe de Code::Blocks fourni une liste de variables recommandées pour divers
packages connus.
Le membre base correspond à la même valeur que celle de la variable utilisée sans membre
(alias).
Code::Blocks 89
Code::Blocks V2.0.1 beta 3.7 Variables globales du compilateur
Les membres include et lib sont par défaut des aliases pour base/include et base/lib , re-
spectivement. Cependant, l’utilisateur peut les redéfinir si une autre configuration est
souhaitée.
Il est généralement recommandé d’utiliser la syntaxe $(#variable.include) plutôt que son
équivalent $(#variable)/include, car elle fournit une flexibilité accrue tout en étant fonc-
tionnellement identique (voir sous-section 3.7.6 à la page 92 et Figure 3.1 à la page 90
pour plus de détails).
Les membres cags et lags sont vides par défaut et peuvent être utilisés pour fournir la
possibilité de remplir un ensemble consistant unique de flags compilateur/éditeur de liens
pour toutes les générations sur une machine donnée. Code::Blocks vous permet de définir
des membres de variables utilisateur en complément de ceux prédéfinis.
Figure 3.1: Variables Globales d’Environnement
3.7.3 Contraintes
Les noms de variables de configuration ou de compilateur ne peuvent pas être vides,
ne peuvent pas contenir de caractères blancs (ou espaces), doivent commencer par
une lettre et ne contenir que des caractères alphanumériques. Les lettres Cyrilliques
ou Chinoises ne sont pas des caractères alphanumériques. Si Code::Blocks rencontre
une séquence de caractères non valides dans un nom, il peut la remplacer sans le
demander.
Toutes les variables nécessitent que leur base soit définie. Tout le reste est optionnel,
mais la base est absolument obligatoire. Si vous ne définissez pas la base d’une
variable, elle ne sera pas sauvegardée (et ce même si les autres champs ont été
définis).
Vous ne pouvez pas définir un nom de membre utilisateur qui a le même nom qu’un
membre prédéfini. Actuellement, le membre utilisateur écrasera le membre prédéfini,
mais en général, le comportement est indéfini dans ce cas.
Les valeurs des variables et des membres peuvent contenir un nombre arbitraire de
séquences de caractères, mais doivent respecter les contraintes suivantes :
Code::Blocks 90
– Vous ne pouvez pas définir une variable par une valeur qui se référence à la
même variable ou à n’importe lequel de ses membres
– Vous ne pouvez pas définir un membre par une valeur qui se référence à ce
même membre
– Vous ne pouvez pas définir un membre ou une variable par une valeur qui se
référence à la même variable ou membre par une dépendance cyclique.
Code::Blocks détectera les cas de définitions récursives les plus évidentes (ce qui peut
arriver par accident), mais il ne fera pas d’analyse en profondeur de tous les cas possibles
abusifs. Si vous entrez n’importe quoi, alors vous obtiendrez n’importe quoi; vous êtes
avertis maintenant.
Exemples
Définir wx.include comme $(#wx)/include est redondant, mais parfaitement légal. Définir
wx.include comme $(#wx.include) est illégal et sera détecté par Code::Blocks. Définir
wx.include comme $(#cb.lib) qui est lui-même défini comme $(#wx.include) créera une
boucle infinie.
3.7.4 Utilisation des Variables Globales du Compilateur

Tout ce que vous avez à faire pour utiliser des variables globales de compilateur c’est de
les mettre dans votre projet! Oui, c’est aussi simple que cela.
Quand l’Environnement Intégré de Développement (IDE) détecte la présence d’une vari-
able globale inconnue, il vous demande d’entrer sa valeur. La valeur sera sauvegardée dans
vos paramètres, ainsi vous n’aurez jamais besoin d’entrer deux fois l’information.
Si vous avez besoin de modifier ou de supprimer une variable plus tard, vous pourrez le
faire depuis le menu des paramètres.
Exemple
L’image ci-contre montre à la fois les variables par-projet et globales. WX_SUFFIX est
défini dans le projet, mais WX est une variable utilisateur globale.
3.7.5 Ensembles de Variables

Parfois, vous voulez utiliser différentes versions d’une même librairie, ou vous développez
deux branches d’un même programme. Bien qu’il soit possible de gérer cela avec une vari-
able globale de compilateur, cela peut devenir fastidieux. Dans ce cas, Code::Blocks sup-
porte des ensembles de variables. Un ensemble de variables est une collection indépendante
de variables, identifiée par un nom (les noms d’ensemble ont les mêmes contraintes que
les noms de variables).
Si vous souhaitez basculer vers un autre ensemble de variables, vous sélectionnez tout
simplement un ensemble différent depuis le menu. Des ensembles différents n’ont pas
obligatoirement les mêmes variables, et des variables identiques dans différents ensembles
n’ont pas forcément les mêmes valeurs, ni même des membres utilisateurs identiques.
Code::Blocks 91
Figure 3.2: Variables Globales
Un autre point positif à propos des ensembles est que si vous avez une douzaine de variables
et que vous voulez obtenir un nouvel ensemble avec une de ces variables pointant vers
un endroit différent, vous n’êtes pas obligés de ré-entrer toutes les données à nouveau.
Vous pouvez simplement créer un clone de l’ensemble courant, ce qui dupliquera toutes
vos variables.
Supprimer un ensemble supprimera également toutes les variables de cet ensemble (mais
pas celles d’une autre ensemble). L’ensemble default est toujours présent et ne peut pas
être supprimé.
3.7.6 Mini-Tutoriel de membres utilisateur

Comme décrit auparavant, écrire $(#var.include) et $(#var)/include revient à la même
chose par défaut. Aussi pourquoi donc écrire quelque chose d’aussi non intuitif que
$(#var.include)?
Prenons l’exemple d’une installation standard de Boost sous Windows. Généralement,
vous vous attendriez à ce qu’un package fictif ACME ait ses fichiers include dans ACME/in-
clude et ses librairies dans ACME/lib. Optionnellement, il pourrait mettre ses en-têtes
(headers) dans un autre sous répertoire appelé acme. Ainsi après avoir ajouté les chemins
corrects dans les options du compilateur et de l’éditeur de liens, vous pouvez vous atten-
dre à #include <acme/acme.h> et éditer les liens avec libacme.a (ou quelque chose de
ce genre).
Boost, cependant, installe les en-têtes dans C:\Boost\include\boost-1 33 1\boost et
ses librairies dans C:\Boost\lib par défaut. Il semble impossible d’obtenir ceci simple-
ment sans devoir tout ajuster sur chaque nouveau PC, particulièrement si vous devez
travailler sous Linux mais aussi avec un autre OS.
Code::Blocks 92
C’est là que la véritable puissance des variables globales utilisateur se révèle. Quand vous
définissez la valeur de la variable #boost, vous allez juste un cran plus loin que d’habitude.
Vous définissez le membre include comme C:\Boost\include\boost-1 33 1\boost et le
membre lib comme C:\Boost\lib, respectivement. Votre projet utilisant $(#boost.include)
et $(#boost.lib) travaillera comme par magie correctement sur tout PC sans aucune mod-
ifications. Vous n’avez pas besoin de savoir pourquoi, vous ne voulez pas savoir pourquoi.
Code::Blocks 93
4 Travailler avec Code::Blocks
Ce chapitre traite de quelques connaissances de base pour pouvoir travailler avec Code::Blocks.
Quelques paragraphes, ici directement repris du Wiki font double emploi mais avec une
présentation un peu différente de ce qu’il y a dans le premier chapitre.
4.1 Le processus de génération de Code::Blocks

Dans ces pages, le processus de génération est expliqué en détail. On y voit ce qui se passe
en arrière-plan et ”quand”. Je vous souhaite une intéressante lecture :).
4.1.1 Étapes successives de la Génération

Comme vous l’avez peut-être déjà compris, Code::Blocks ne lance pas au hasard les
commandes de génération, mais effectue plutôt une séquence d’étapes bien pensées et
préparées. Mais avant tout, regardons les différents composants qui sont utilisés lors d’une
génération:
Espace de Travail : contient un ou plusieurs projets (dénommé aussi workspace, comme
en anglais)
Projet : contient une ou plusieurs cibles de génération. Il contient également les fichiers
de projet.
Cible de génération : ce sont les variantes de projet qui lui-sont assignés, et qui seront
générées par groupes afin de produire une sortie binaire. Cette sortie peut être soit
un exécutable, une librairie dynamique ou statique. NOTE : Il existe un type de
cible de génération qui ne produit pas directement une sortie binaire mais se contente
plutôt de seulement réaliser des étapes de pre/post génération (qui peuvent générer
de façon externe une sortie binaire).
Décomposons ces sujets en sections et expliquons-les en détail.
4.1.2 Espace de Travail

Un espace de travail (ou Workspace) est un conteneur (celui de plus haut niveau) utilisé
pour organiser vos projets. Comme il ne peut y avoir qu’un seul espace de travail ouvert
à la fois, il n’y a pas d’ordre spécifique les concernant. Un seul espace, donc il suffit de le
générer ;).
Utilisez le menu ’Générer’ →’Générer l’espace de travail’ pour générer l’espace de travail
(c.à.d. tous les projets qui y sont contenus).
4.1.3 Projets
C’est ici que les choses deviennent intéressantes :).
Code::Blocks V2.0.1 beta 4.1 Le processus de génération de Code::Blocks
L’ordre de génération des projets est différent suivant que l’utilisateur a indiqué s’il y a
des dépendances ou pas entre les projets. Alors, allons-y...
Sans dépendances inter-projets
Dans ce cas, les projets sont générés dans l’ordre d’apparition, du haut vers le bas. Dans
la plupart des projets cependant (sauf ceux du genre ”hello world”), vous allez vouloir
créer des dépendances entre projets.
Utilisation de dépendances entre projets
Les dépendances de projets sont une façon simple d’indiquer à Code::Blocks qu’un projet
donné ”dépend” d’un autre (toujours dans le même espace de travail).
Alors imaginons que, dans votre espace de travail, vous avez un projet de librairie et
un projet d’exécutable qui dépend de cette librairie. Vous pouvez alors (et devez) in-
former Code::Blocks de cette dépendance. Pour faire cela, vous sélectionnez ’Projet’
→’Propriétés’ et cliquez sur le bouton des ”Dépendances de Projet...”.
Veuillez noter que les informations de dépendances sont enregistrées dans le fichier de
l’espace de travail, et non dans un fichier projet car les dépendances se font entre deux
projets à l’intérieur d’un même espace de travail.
Figure 4.1: Configuration de dépendances de projet
C’est très facile d’utiliser ce dialogue. Sélectionnez le projet sur lequel vous voulez ajouter
une dépendance et cochez la case sur tous les projets dont ce projet de base dépend. Cela
aura pour conséquence que tous les projets que vous avez coché seront générés avant le
projet qui en dépend, assurant ainsi une génération synchronisée.
Code::Blocks 95
Astuce : Vous n’avez pas à fermer ce dialogue et lancer d’autres propriétés de pro-
jets de nouveau pour configurer leurs dépendances. Vous pouvez configurer toutes les
dépendances de projets depuis cette même boı̂te de dialogue. Sélectionnez simplement un
autre projet dans le menu déroulant :).
Quelques choses à noter :
Les dépendances sont configurées directement ou indirectement. Si le projet A
dépend directement du projet B et que le projet B dépend du projet C, alors le
projet A dépend également du projet C, mais indirectement.
Code::Blocks est suffisamment intelligent pour vérifier s’il y a des dépendances cir-
culaires et donc les interdire. Une dépendance circulaire est obtenue quand un projet
A dépend directement ou indirectement d’un projet B et que le projet B dépend
directement ou indirectement du projet A.
Les dépendances prennent effet soit lors de la génération d’un espace de travail entier
soit sur un projet seul. Dans ce cas, seules les dépendances nécessaires au projet que
vous êtes en train de générer seront aussi générées.
4.1.4 Génération de Cibles

L’ordre de génération des cibles dépend de deux choses.
1. Si l’utilisateur a sélectionné une cible particulière dans le menu déroulant de la barre
de compilation, alors seule cette cible sera générée. Si des dépendances de projet
ont été configurées pour le projet contenant cette cible, tous les projets dépendants
génèreront aussi leur cible sous le même nom. Si une telle cible n’existe pas, on passe
au projet suivant.
2. Si la cible virtuelle ”All” est sélectionnée, alors toutes les cibles dans le projet (et
tous les projets dépendants) sont générés dans l’ordre du haut vers le bas. Il y a
deux exceptions à cela :
Une cible n’est pas générée par ”All” si l’option de cible (dans la page des
propriétés du projet ”Cibles de génération”) ”Générer cette cible par All” n’est
pas sélectionnée.
Si aucune cible du projet n’a de sélectionnées l’option ci-dessus, alors la cible
”All” n’apparait pas dans la liste.
4.1.5 Phase de Preprocessing

Avant que le processus de génération démarre (c.à.d. commence l’exécution des comman-
des de compilation/édition de liens), une étape de preprocessing est lancée pour générer
toutes les lignes de commandes du processus complet de génération. Cette étape place
dans un cache la plupart des informations qu’elle génère, ce qui a pour effet de rendre les
générations suivantes plus rapides.
Cette étape lance aussi tout script de génération qui y est attaché.
Code::Blocks 96
4.1.6 Commandes réelles d’exécution

C’est l’étape, du point de vue de l’utilisateur, où le processus de génération commence
réellement. Les fichiers commencent à être compilés et au final liés entre eux pour générer
les diverses sorties binaires définies par les cibles de génération.
Dans cette étape sont aussi exécutées les cibles de pré-génération et de post-génération.
4.1.7 Étape de pré-génération et post-génération

Ce sont des commandes qui peuvent être configurées au niveau projet et/ou au niveau
cible. Ce sont des commandes Shell qui par exemple copient des fichiers ou toute autre
opération que vous pouvez réaliser par les commandes Shell habituelles de l’OS.
Les variables spécifiées dans le paragraphe Expansion de Variables (chapitre 3 à la page 82)
peuvent être utilisées dans les scripts afin de récupérer des informations comme le répertoire
de sortie, le répertoire de projet, le type de cible ou autres.
Vous avez ci-dessous le déroulé dans l’ordre d’exécution des étapes de pré/post génération
d’un projet imaginaire avec 2 cibles (Debug/Release) :
1. Étapes de pré-génération du Projet
a) Target ”Debug” étapes de pré-génération
b) Target ”Debug” compilation des fichiers
c) Target ”Debug” édition de liens des fichiers et génération de la sortie binaire
d) Target ”Debug” étapes de post-génération (voir les notes ci-dessous)
e) Target ”Release” étapes de pré-génération
f) Target ”Release” compilation des fichiers
g) Target ”Release” édition de liens des fichiers et génération de la sortie binaire
h) Target ”Release” étapes de post-génération (voir les notes ci-dessous)
2. Étapes de post-génération du Projet
J’espère que c’est suffisamment clair :)
Note :
Les étapes de Pré-génération sont toujours exécutées. Les étapes de
Post-génération ne seront exécutées que si le projet/cible auxquelles
elles sont rattachées n’est pas à jour (c.à.d. en train d’être généré).
Vous pouvez changer cela en sélectionnant ”Toujours exécuter, même
si la cible est à jour” dans les options de génération.
Exemples de Script
Script de Post-génération qui copie le fichier de sortie dans un répertoire C:\Program\bin
sous Windows :
Code::Blocks 97
Code::Blocks V2.0.1 beta 4.2 Création d’un Nouveau Projet
cmd / c copy ” $ (PROJECT DIR) $ (TARGET OUTPUT FILE) ” ”C: \ Program \ b i n ”
Exécution du script bash ”copyresources.sh” sous Linux :

/ b i n / sh c o p y r e s o u r c e s . sh
Création d’un nouveau répertoire dans le répertoire de sortie :

mkdir $ (TARGET OUTPUT DIR) / data
4.2 Création d’un Nouveau Projet

Ces pages sont un guide sur les fonctionnalités de base (et quelques intermédiaires) pour
la création et la modification d’un projet Code::Blocks. Si c’est votre première exéprience
avec Code::Blocks, alors ceci est un bon point de départ.
4.2.1 L’assistant de Projet

Lancez l’assistant de Projet par ’Fichier’ →’Nouveau’ →’Projet...’ afin de démarrer un
nouveau projet. Ici, il y a plusieurs modèles pré-configurés pour divers types de projets, in-
cluant l’option de création de modèles personnalisés. Sélectionnez Console application,
car c’est le plus commun pour un usage général, puis cliquez sur Aller ou Go.
Figure 4.2: L’assistant de Projet
Note :
Un texte en rouge au lieu d’un texte en noir sous n’importe quelle
icône signifie que l’on utilise un script assistant personnalisé.
Code::Blocks 98
L’assistant Application console apparaitra ensuite. Continuez dans les menus, en sélectionnant
C++ quand on vous demandera le langage. Sur l’écran suivant, donnez un nom au
projet et tapez ou sélectionnez un répertoire de destination. Comme on voit ci-dessous,
Code::Blocks génèrera les entrées restantes à partir de ces deux là.
Figure 4.3: Application Console
Finalement, l’assistant vous demandera si ce projet doit utiliser le compilateur par défaut
(normalement GCC) et les deux générations par défaut : Debug et Release. Toutes
ces configurations sont correctes. Appuyez sur Terminer et le projet va se générer. La
fenêtre principale va se griser, mais ce n’est pas un problème, le fichier source doit encore
être ouvert. Dans l’onglet Projets du panneau de Gestion sur la gauche, dépliez les
répertoires et double-cliquez sur le fichier source main.cpp afin de l’ouvrir dans l’éditeur.
Figure 4.4: Selection d’un fichier Source
Ce fichier contient le code standard suivant.

main.cpp
Code::Blocks 99

u s i n g namespace s t d ;
int main ( )
{
c o u t << ” H e l l o world ! ” << e n d l ;
return 0 ;
}
4.2.2 Changer la composition du fichier

Un simple fichier source est d’un intérêt limité dans des programmes plus ou moins com-
plexes. Pour traiter cela, Code::Blocks possède plusieurs méthodes très simples permettant
d’ajouter des fichiers supplémentaires au projet.
Ajout d’un fichier vide
Dans cet exemple, nous allons isoler la fonction
main.cpp
dans un fichier séparé.
Note :
Généralement, c’est un mauvais style de programmation que de créer
une fonction dans un aussi petit fichier ; ici, ce n’est fait qu’à titre
d’exemple.
Pour ajouter un nouveau fichier au projet, appelez l’assistant de modèle de fichier soit
par le ’Fichier’ →’Nouveau’ →’Fichier...’ soit par ’Barre d’outils principale’ →’Nouveau
fichier (bouton)’ →’Fichier...’ Utilisez le menu ’Générer’ →’Générer l’espace de travail’
pour générer un espace de travail (c.a.d tous les projets qui y sont contenus).
Figure 4.5: Nouveau Fichier
Sélectionnez la source en C/C++ et cliquez sur Aller (ou Go). Continuez dans les
dialogues suivants tout comme lors de la création du projet original, en sélectionnant
Code::Blocks 100
C++ quand on vous demandera le langage. La page finale vous présentera plusieurs
options. La première boı̂te détermine le nouveau nom du fichier et l’emplacement (comme
noté, le chemin complet est requis). Vous pouvez utiliser en option le bouton ... pour
afficher une fenêtre de navigateur de fichiers pour enregistrer l’emplacement du fichier.
En cochant Ajouter le fichier au projet actif vous enregistrerez le nom du fichier
dans le répertoire Sources de l’onglet Projets du panneau de Gestion. En cochant
une ou plusieurs cibles de génération vous informerez Code::Blocks que le fichier devra
être compilé puis de faire l’édition de liens pour la(les) cible(s) sélectionnée(s). Ce peut
être utile si, par exemple, le fichier contient du code spécifique de débogage, car cela
permettra l’inclusion dans (ou l’exclusion de) la (les) cible(s) de génération appropriée(s).
Dans cet exemple, toutefois, la fonction hello est indispensable, et donc requise dans toutes
les sources. Par conséquent, sélectionnez toutes les cases et cliquez sur Terminer pour
générer le fichier.
Figure 4.6: Configurations du Programme Hello
Le fichier nouvellement créé devrait s’ouvrir automatiquement ; si ce n’est pas le cas,

ouvrez le en double-cliquant sur ce fichier dans l’onglet Projets du panneau de Gestion.
Ajoutez-y maintenant le code de la fonction que main.cpp appelera.
hello.cpp
u s i n g namespace s t d ;
void h e l l o ( )
{
}
Code::Blocks 101
Ajout d’un fichier déjà existant

Maintenant que la fonction hello() est dans un fichier séparé, la fonction doit être déclarée
dans main.cpp pour pouvoir être utilisée. Lancez un éditeur de texte (par exemple
Notepad ou Gedit), et ajoutez le code suivant :
hello.h
#i f n d e f HELLO H INCLUDED
#define HELLO H INCLUDED
void h e l l o ( ) ;
#endif // HELLO H INCLUDED
Enregistrez ce fichier en tant que fichier d’en-tête (hello.h) dans le même répertoire
que les autres fichiers source de ce projet. Revenez dans Code::Blocks, cliquez sur ’Pro-
jet’ →’Ajouter des fichiers...’ pour ouvrir un navigateur de fichiers. Là, vous pouvez
sélectionner un ou plusieurs fichiers (en utilisant les combinations de Ctrl et Maj ). (L’option
’Projet’ →’Ajouter des fichiers récursivement...’ va chercher dans tous les sous-répertoires
d’un répertoire donné, en sélectionnant les fichiers adéquats à inclure.) Sélectionnez hello.h,
et cliquez sur Open pour obtenir le dialoque vous demandant dans quelles cibles le(les)
fichiers doivent appartenir. Dans cet exemple, sélectionnez les deux cibles.
Figure 4.7: Appartenance aux cibles de génération
Note :
Si le projet en cours n’a qu’une seule cible, on ne passera pas par ce
dialogue.
De retour dans le source principal (main.cpp), incluez le fichier d’en-tête et replacez la

fonction cout afin de se conformer à la nouvelle configuration du projet.
main.cpp
Code::Blocks 102
#include ” h e l l o . h”
int main ( )
{
hello ();
return 0 ;
}
Pressez Ctrl-F9, ’Générer’ →’Générer’ , ou ’Barre d’outils du Compilateur’ →’Générer

(bouton - la roue dentée)’ pour compiler le projet. Si la sortie suivante s’affiche dans
le journal de génération (dans le panneau du bas) c’est que toutes les étapes se sont
correctement déroulées.
============== B u i l d : Debug i n HelloWorld ===============
Compiling : main . cpp

Compiling : h e l l o . cpp
L i n k i n g c o n s o l e e x e c u t a b l e : b i n \Debug\ HelloWorld . exe
Output s i z e i s 9 2 3 . 2 5 KB
P r o c e s s t e r m i n a t e d with s t a t u s 0 ( 0 minutes , 0 s e c o n d s )
0 e r r o r s , 0 w a r n i n g s ( 0 minutes , 0 s e c o n d s )
L’exécutable peut maintenant être lancé soit en cliquant sur le bouton Run soit en tapant
sur Ctrl-F10.
Note :
L’option F9 (pour Générer et exécuter) combine ces commandes, et
peut être encore plus utile dans certaines situations.
Observez le processus de génération de Code::Blocks pour voir ce qui se passe en arrière-

plan lors d’une compilation.
Suppression d’un fichier
En utilisant les étapes ci-dessus, ajoutez un nouveau fichier source C++, useless.cpp,
au projet. La suppression de ce fichier inutile dans le projet est triviale. Faites tout
simplement un clic droit sur useless.cpp dans l’onglet Projets du panneau de Gestion
puis sélectionnez Enlever le fichier du projet.
Code::Blocks 103
Figure 4.8: Enlever un fichier d’un projet
Note :
Enlever un fichier d’un projet ne le supprime pas physiquement ;
Code::Blocks l’enlève seulement de la gestion du projet.
4.2.3 Modifier les Options de Génération

Jusqu’ici, les cibles de génération ont été évoquées à plusieurs reprises. Changer entre
les 2 versions générées par défaut - Debug et Release - peut simplement se faire via le
menu déroulant de la Barre d’outils de Compilation. Chacune de ces cibles qui peut
être choisie parmi différents types (par exemple : librairie statique ; application console),
contient differentes configurations de fichiers source, variables personnalisées, différents
commutateurs de génération (par exemple : symboles de débogage -p ; optimisation de la
taille -Os ; optimisations à l’édition de liens -flto), et bien d’autres options.
Figure 4.9: Sélection de Cible
Le menu ’Ouvrir un Projet’ →’Propriétés...’ permet d’accéder aux propriétés principales

du projet actif, HelloWorld. La plupart des configurations du premier onglet, Config-
uration du Projet, changent rarement. Titre : permet de changer le nom du projet. Si
Platforme: est changé en toute autre valeur que celle par défaut All, Code::Blocks ne
vous permettra de générer que les cibles sélectionnées. Ceci est utile, par exemple, si le
code source contient de l’API Windows, et serait donc non valide ailleurs que sous Win-
dows (ou toutes autres situations dépendant spécifiquement du système d’exploitation).
Makefile: options qui sont utilisées si le projet doit utiliser un makefile plutôt que le
Code::Blocks 104
système de génération interne de Code::Blocks’ (voir Code::Blocks et les Makefiles [?? à

la page ?? pour plus details).
Ajouter une nouvelle cible de génération
Basculez vers l’onglet Générer les cibles. Cliquez sur Ajouter pour créer une nou-
velle cible de génération et nommez-là Release Small. La mise en avant dans la colonne
de gauche devrait automatiquement basculer sur la nouvelle cible (si ce n’est pas le cas,
cliquez dessus pour changer le focus). Comme la configuration par défaut de Type: - ”Ap-
plication graphique” - est incorrecte pour un programme de type HelloWorld, changez-
le en ”Application console” via la liste déroulante. Le nom du fichier de sortie Hel-
loWorld.exe est correct sauf que la sortie de l’exécutable se fera dans le répertoire prin-
cipal. Ajoutez le chemin ”bin\ReleaseSmall\” (Windows) ou ”bin/ReleaseSmall/” (Linux)
devant le nom pour changer ce répertoire (c’est un chemin en relatif par rapport à la racine
du projet). Le Répertoire de travail d’exécution: se rapporte à l’emplacement ou
sera exécuté le programme lorsqu’on sélectionnera Exécuter ou Générer et exécuter.
La configuration par défaut ”.” est correcte (elle se réfère au répertoire du projet). Le
Répertoire de sortie des objets: doit être changé en ”obj\ReleaseSmall\” (Win-
dows) ou ”obj/ReleaseSmall/” (Linux) de façon à rester cohérent avec le reste du projet.
Générer les fichiers cibles: pour l’instant, rien n’y est sélectionné. C’est un problème,
car rien ne sera compilé si on génère cette cible. Cochez toutes les cases.
Figure 4.10: Options de Cible
Code::Blocks 105
L’étape suivante est de changer les paramètres de cible. Cliquez sur Options de génération...
pour accéder aux paramètres. Le premier onglet qui s’affiche possède toute une série de
commutateurs de compilation (flags) accessibles via des cases à cocher. Sélectionnez ”Re-
tirez tous les symboles du binaire” et ”Optimiser le code généré pour la taille”. Les flags
ici contiennent bien d’autres options communément utilisées, cependant, on peut passer
outre. Basculez vers le sous-onglet Autres options et ajoutez-y les commutateurs suiv-
ants :
= fno = r t t i
= fno = e x c e p t i o n s
=f f u n c t i o n =s e c t i o n s
=f d a t a = s e c t i o n s
=f l t o
Maintenant basculer dans l’onglet Options de l’éditeur de liens. La boı̂te Librairies à

lier: vous affiche un bouton pour ajouter diverses librairies (par exemple, wxmsw28u pour
la version Windows Unicode de la librairie dynamique wxWidgets monolithique version
2.8). Ce programme ne requiert pas de telles librairies. Les commutateurs personnalisés
de l’étape précédente requièrent leur contrepartie lors de l’édition de liens. Ajoutez
=f l t o
=Os
=Wl,== gc = s e c t i o n s
= shared = l i b g c c
= shared = l i b s t d c++
dans l’onglet Autre options de l’éditeur de liens :. (Pour plus de détails sur ce que font
ces commutateurs, se référer à la documentation de GCC sur les options d’optimisation
et les options de l’éditeur de liens.)
Cibles Virtuelles
Cliquez sur OK pour accepter ces changements et retournez au dialogue précédent. Main-
tenant, vous avez deux cibles de génération ”Release”, qui auront deux compilations
séparées pour lancer Générer ou Générer et exécuter. Heureusement, Code::Blocks
possède une option pour enchaı̂ner plusieurs générations ensemble. Cliquez sur Cibles
Virtuelles..., puis Ajouter. Nommez la cible virtuelle Releases puis cliquez sur OK.
Dans la boı̂te de droite Générer les cibles contenues, sélectionnez les deux Release
et Release small. Fermez cette boı̂te et cliquez sur OK dans la fenètre principale.
Code::Blocks 106
Code::Blocks V2.0.1 beta 4.3 Débogage avec Code::Blocks
Figure 4.11: Cibles Virtuelles
La cible virtuelle ”Releases” est maintenant disponible dans la barre d’outils du Compi-
lateur ; la générer produira les sorties suivantes :
============== B u i l d : R e l e a s e i n HelloWorld ===============

L i n k i n g c o n s o l e e x e c u t a b l e : b i n \ R e l e a s e \ HelloWorld . exe
Output s i z e i s 4 5 7 . 5 0 KB
============== B u i l d : R e l e a s e Small i n HelloWorld ===============

L i n k i n g c o n s o l e e x e c u t a b l e : b i n \ R e l e a s e S m a l l \ HelloWorld . exe
Output s i z e i s 8 . 0 0 KB
P r o c e s s t e r m i n a t e d with s t a t u s 0 ( 0 minutes , 1 s e c o n d s )
0 e r r o r s , 0 w a r n i n g s ( 0 minutes , 1 s e c o n d s )
4.3 Débogage avec Code::Blocks

Cette section décrit comment travailler ne mode débogage.
4.3.1 Générer une version ”Debug” de votre Projet

Assurez-vous que le projet soit compilé avec l’option de compilation -g (symboles de
débogage) activée, et que l’option -s (supprimer les symboles) soit désactivée. Ainsi, vous
vous assurez que les symboles de débogage sont bien inclus dans l’exécutable.
Les commutateurs d’optimisations du compilateur doivent êtres désactivés, en particulier
(-s) qui doit être sur ”off”.
Gardez à l’esprit que vous devrez peut-être re-générer votre projet car les fichiers objets
bien qu’à jour peuvent ne pas avoir été re-compilés avec -g. SVP, prenez garde au fait
Code::Blocks 107
que dans les compilateurs autres que GCC, -g et/ou -s peuvent être des commutateurs
différents (-s peut ne pas être du tout disponible).
’Menu’ →’Projet’ →’Options de génération’
Figure 4.12: Options de Débogage de Génération de Projet
4.3.2 Ajout de Témoins

Dans la version 10.05
Note :
C’est une très vieille version. Vous ne devriez plus l’utiliser
Ouvrez la fenêtre des Témoins du Débugueur.
Code::Blocks 108
Figure 4.13: Ouvrir une fenêtre Témoins du débugueur
La liste des témoins peut être enregistrée dans un fichier et rechargée plus tard. Pour ce
faire, clic droit dans la liste des témoins et sélectionnez ”enregistrer dans un fichier de
témoins” (puis ”charger un fichier de témoins” pour les recharger).
Figure 4.14: Enregistrer une fenêtre de Témoins
Depuis la version 12.11 et les dernières générations ”nightly”

Dans les dernières générations ”nightly” la fenêtre des Témoins a été revue et donc fonc-
tionne différemment de ce qu’il y avait en 10.05.
Actuellement, il y a trois façons d’y ajouter des témoins :
1. Cliquez sur la dernière ligne (vide) dans la fenêtre des témoins, tapez le nom de la
variable (ou une expression complète) puis tapez sur la touche entrée.
Code::Blocks 109
2. Quand le débugueur est arrêté sur un point d’arrêt, sélectionnez un nom de vari-
able ou une expression complète, clic droit pour ouvrir un menu de contexte puis
sélectionnez ”Ajouter un témoin ’expression’”.
3. Sélectionnez une expression dans l’éditeur puis glissez-déposez là dans la fenêtre des
témoins.
L’inclusion automatique des variables locales et des arguments de fonction ont été ré-
implémentés en version 13.12.
4.3.3 Double-clic dans la fenêtre de pile d’Appels

Note :
Quand on débugue, un double-clic dans une frame de la ”pile d’appel”
d’une fenêtre de débogage ne met pas à jour automatiquement les
variables affichées dans la fenêtre de débogage des ”témoins”.
Vous devez effectuer un clic droit dans la frame de la fenêtre de débogage de la ”pile
d’appel” et sélectionner ”Basculer vers cette frame”.
Figure 4.15: Une Fenêtre de Témoins
Code::Blocks 110
4.3.4 Activer des Points d’Arrêt

Recherchez la ligne contenant la variable que vous voulez observer. Placez un point d’arrêt
à un endroit qui vous permettra d’observer la valeur de la variable.
’Menu’ →’Débugueur’ →’Inverser le point d’arrêt’
Figure 4.16: Configuration des Variables Témoins
Lancez le débugueur jusqu’à ce qu’il atteigne le point d’arrêt. Clic droit sur la variable
pour configurer un témoin dans la fenêtre des témoins.
Les points d’arrêts peuvent aussi être obtenus ou inversés par un clic gauche dans la marge
gauche de l’éditeur.
4.3.5 Notes
Support de Scripts
Code::Blocks utilise en natif le langage de scripts squirrel pour travailler avec gdb, voir:
Scripts du Débugueur (section 4.4 à la page 113). Depuis la version 7.X, gdb supporte les
”pretty printer” de python, et donc, il peut aussi utiliser gdb (avec le support python)
pour afficher des valeurs complexes de variables. Voir dans les forum le fil ”unofficial
MinGW GDB gdb with python released” et ”Use GDB python under Codeblocks” pour
Code::Blocks 111
plus de détails.
Débogage d’un fichier seul
Pour débuguer votre programme vous devez absolument configurer un projet. Les pro-
grammes ne consistant qu’en un seul fichier, sans projet associé, ne sont pas supportés.
Chemin avec espaces
Les points d’arrêts ne peuvent pas fonctionner si le chemin et/ou le nom du répertoire où
vous avez placé votre projet contient des espaces ou d’autres caractères spéciaux. Pour
être sûr du coup, n’utilisez que des lettres anglaises, des chiffres et le caractère ’ ’.
”Forking”
Si votre application utilise le système d’appel ’fork’ vous aurez des problèmes pour arrêter
le programme en cours de débogage ou pour configurer des points d’arrêts à la volée.
Voici un lien expliquant les modes forking de GDB : http://sourceware.org/gdb/
onlinedocs/gdb/Forks.html
Mise à jour vers une version plus récente de MinGW
Depuis la version 6.8 de gdb d’Avril 2008, il supporte de nombreuses fonctionnalités qui
n’existaient pas dans les versions antérieures. Vous pouvez obtenir une mise à jour en
installant les binaires depuis les packages MinGW64 sur SourceForge.
Note :
Le package TDM-Mingw était un bon choix jusqu’à la version 5.1,
mais le développement est aujourd’hui abandonné.
Utilisation de CDB 32bit pour des programmes 32bit et CDB 64bit pour des
programmes 64bit
Il semble que le débogage d’un programme 32bit avec CDB 64bit ne fonctionne pas sous
Windows 7 (et plus ?), mais CDB 32bit fonctionne parfaitement.
Note :
Ceci ne devrait plus être le cas depuis Code::Blocks rev>=10920. Pour
plus de détails voir le ticket : #429
Limites des versions antérieures de MinGW

Si vous utilisez encore MinGW et gdb 6.7 fourni avec la version 8.02 de Code::Blocks, la
mise en place de points d’arrêts dans un constructeur ne fonctionnera pas. Voici quelques
astuces.
Les points d’arrêt ne fonctionnent pas dans les constructeurs ou les destructeurs dans GDB
6.7 ou toute version antérieure. Cependant, ils fonctionnent dans des routines appelées
depuis là. C’est une restriction des versions anciennes de GDB, pas un bug. Alors, vous
pouvez faire quelque chose comme :
Code::Blocks 112
Code::Blocks V2.0.1 beta 4.4 Scripts du Débugueur
Figure 4.17: Débuguer avec un ancien GDB
...et placer un point d’arrêt dans ”DebugCtorDtor” sur la ligne "int i = 0;". Le débugueur
s’arrêtera sur cette ligne. Si vous avancez alors pas à pas dans le débogage (’Menu
Débugueur’ →’Ligne suivante’ ; ou de façon alternative F7) vous atteindrez le code dans
le constructeur/destructeur (”is initialized = true/false;”).
4.4 Scripts du Débugueur

Cette section décrit les scripts du débugueur.
Code::Blocks 113
4.4.1 Principe de Base des scripts du débugueur
Figure 4.18: Commande de Débugueur
Regardez l’image ci-dessus. Cela vous donnera un bref aperçu de comment les scripts du
débugueur fonctionnent. Par exemple, vous voulez observer la variable ”msg”. Il y a deux
échanges entre l’extension du débugueur et gdb.
Premièrement, l’extension du débugueur envoie une commande à gdb pour l’interroger
sur le type de msg
w h a t i s msg
alors, gdb lui retournera le type

type = wxString
Deuxièmement, le débugger vérifie que wxString est déjà enregistré, puis envoie la com-
mande
output / c msg . m pchData [ 0 ]@( ( wxStringData * ) msg . m pchData =1)=>nDataLength
Puis, gdb répond avec la chaı̂ne ci-dessous :

{119 ’w ’ , 120 ’ x ’ , 87 ’W’ , 105 ’ i ’ , 100 ’ d ’ , 103 ’ g ’ , 101 ’ e ’ , 116 ’ t ’ ,
115 ’ s ’ , 32 ’ ’ , 50 ’ 2 ’ , 46 ’ . ’ , 56 ’ 8 ’ , 46 ’ . ’ , 49 ’ 1 ’ , 48 ’ 0 ’ , 45 ’= ’ ,
87 ’W’ , 105 ’ i ’ , 110 ’ n ’ , 100 ’ d ’ , 111 ’ o ’ , 119 ’w ’ , 115 ’ s ’ , 45 ’= ’ ,
85 ’U ’ , 110 ’ n ’ , 105 ’ i ’ , 99 ’ c ’ , 111 ’ o ’ , 100 ’ d ’ , 101 ’ e ’ , 32 ’ ’ ,
98 ’ b ’ , 117 ’ u ’ , 105 ’ i ’ , 108 ’ l ’ , 100 ’ d ’ }
Finalement, la valeur est affichée dans la fenêtre des témoins.
Code::Blocks 114
4.4.2 Fonctions Script

Les scripts du débugueur sont semblables à ceux du visualiseur du débugueur de Visual
Studio. Ils vous permettent d’écrire un petit bout de code qui sera exécuté par le débugueur
dès lors que vous essaierez de regarder un type particulier de variables et peut être utilisé
pour afficher du texte personnalisé comportant une information importante dont vous
avez besoin.
Remarque dans Game Ender - March 23, 2006
Je ne pense pas qu’il soit possible d’ouvrir une autre fenêtre pour y visualiser quelque
chose.
Regardons maintenant comment cela fonctionne. Tout est à l’intérieur d’un seul fichier
placé dans le répertoire des scripts/, dénommé gdb types.script :). Le support pour plus
de scripts (définis par l’utilisateur) est envisagé dans le futur.
Ce script est appelé par Code::Blocks en deux endroits :
1. quand GDB est lancé. Il appelle la fonction script RegisterTypes() pour enregistrer
tous les types définis par l’utilisateur reconnus par le débugueur dans Code::Blocks.
2. dès lors que GDB rencontre votre type de variable, il appelle les fonctions script
spécifiques de ce type de données (enregistrées dans RegisterTypes() - davantage
ci-dessous).
Ceci est un premier aperçu. Regardons en détail le contenu du fichier gdb types.script
fournit et voyons comment il ajoute le support de std :: string dans GDB.
// R e g i s t e r s new t y p e s with d r i v e r
function RegisterTypes ( driver )
{
// signature :
// d r i v e r . R e g i s t e r T y p e ( type name , regex , e v a l f u n c , p a r s e f u n c ) ;
// STL S t r i n g
d r i v e r . RegisterType (
T ( ”STL S t r i n g ” ) ,
T ( ” [ ˆ [ : alnum : ] ]+ s t r i n g [ ˆ [ : alnum : ] ] * ” ) ,
T(” Evaluate StlString ” ) ,
T(” Parse StlString ”)
);
}
Le paramètre ”driver” est le driver du débugueur mais vous n’avez pas besoin de vous en
soucier :) (actuellement, ça ne marche que dans GDB). Cette classe contient une seule
méthode : RegisterType. Voici sa déclaration en C++ :
void GDB driver : : R e g i s t e r T y p e ( const wxString& name , const wxString& regex ,
const wxString& e v a l f u n c , const wxString& p a r s e f u n c )
Donc, dans le code du script ci-dessus, le type ”STL String” (seulement un nom - qu’importe
ce que c’est) est enregistré, fournissant une expression régulière de contrôle sous forme de
Code::Blocks 115
chaı̂ne de caractères pour l’extension débugueur et, au final, il fournit les noms de deux
fonctions indispensables, nécessaires pour chaque type enregistré :
1. fonction d’évaluation : doit retourner la commande comprise par le débugueur
courant (GDB en l’occurrence). Pour ”STL string”, la fonction d’évaluation retourne
une commande de ”sortie” de GDB qui sera exécutée par de débugueur GDB.
2. fonction d’analyse : une fois que le débugueur a lancé la commande retournée par
la fonction d’évaluation, il passe ses résultats à cette fonction pour des traite-
ments complémentaires. Ce que cette fonction retourne, c’est ce qui est affiché
par Code::Blocks (habituellement dans la fenêtre des témoins ou dans une fenêtre
d’astuces (tooltip)).
Regardons la fonction d’évaluation pour std :: string :
f u n c t i o n E v a l u a t e S t l S t r i n g ( type , a s t r , s t a r t , count )
{
l o c a l oper = T ( ” . ” ) ;
i f ( type . Find ( T ( ” * ” ) ) > 0 )

o p e r = T ( ”=>” ) ;
l o c a l r e s u l t = T ( ” output ” ) + a s t r + o p e r + T ( ” c s t r ( ) [ ” )
+ s t a r t + T ( ” ]@” ) ;
i f ( count != 0 )
r e s u l t = r e s u l t + count ;
else
r e s u l t = r e s u l t + a s t r + oper + T ( ” s i z e ( ) ” ) ;
return r e s u l t ;
}
Je ne vais pas expliquer ce que cette fonction retourne. Je vais juste vous dire qu’elle re-
tourne une commande GDB qui fera que GDB imprimera le contenu réel de la std :: string .
Oui, vous devrez connaitre votre débugueur et ses commandes avant d’essayer d’étendre
ses fonctions.
Ce que je vais vous dire toutefois, c’est ce que sont les arguments de ces fonctions.
type: le type de données, par ex. ”char*”, ”const string”, etc.
a_str: le nom de la variable que GDB est en train d’évaluer.
start: l’offset de départ (utilisé pour les tableaux (ou arrays)).
count: le compteur démarrant depuis l’offset de départ (utilisé pour les tableaux).
Voyons maintenant la fonction d’analyse utile :
function Parse StlString ( a str , start )
{
// n o t h i n g n e e d s t o be done
return a s t r ;
}
Code::Blocks 116
Code::Blocks V2.0.1 beta 4.5 Code::Blocks et les Makefiles
a_str: la chaı̂ne retournée quand GDB a été exécuté et retournée par la fonction
d’évaluation. Dans le cas de std :: string , c’est le contenu de la chaı̂ne.
start: l’offset de départ (utilisé pour les tableaux).
Bon, dans cet exemple, il n’y a rien besoin de faire. ”a_str” contient déjà le contenu de
std: string et donc il suffit de retourner la chaı̂ne:)
Je vous suggère d’étudier comment wxString est enregistré dans ce même fichier, en tant
qu’exemple plus complexe.
4.5 Code::Blocks et les Makefiles

Cette section décrit comment utiliser un makefile dans Code::Blocks en utilisant un ex-
emple wxWidgets.
4.5.1 Article du Wiki

Auteur : Gavrillo 22:34, 21 Mai 2010 (UTC)
Par défaut, Code::Blocks n’utilise pas de makefile. Il a ses propres fichiers de projets .cbp
qui font la même chose automatiquement. Il y a quelques raisons pour lesquelles vous
voudriez utiliser un makefile. Vous êtes peut-être en train de migrer dans Code::Blocks un
projet qui possède un makefile. Une autre possibilité est que vous voulez que votre projet
puisse être généré sans Code::Blocks.
Le besoin d’utiliser un pré-processeur n’est pas une raison valable pour utiliser un makefile
dans la mesure où Code::Blocks a des options de pre/post génération. Depuis le menu
’Projet’ →’Options de génération’ elles apparaissent dans un onglet avec les étapes de
pre/post génération, qui peuvent être utilisées à cet effet.
Ce paragraphe traite plus spécifiquement des makefiles qui utilisent mingw32-make 3.81,
CB 8.02 et wxWidgets 2.8 sous Windows Vista, bien qu’il soit presque certain que cela
s’applique à d’autres configurations.
Si vous décidez d’utiliser votre propre makefile, vous devez aller sur l’écran de ’Projet’
→’Propriétés’ et vous verrez la case à cocher ’ceci est un makefile personnalisé’. Cochez
cette case, assurez-vous que le nom placé juste au-dessus est celui que vous voulez pour
votre makefile.
Vous devriez aussi regarder dans ’Projet’ →’Options de génération’ . Il y a un onglet
dénommé ’Commandes du Make’ (vous avez à déplacer horizontalement les onglets pour
tomber dessus). Dans le champ ’Génération du projet/cible’ vous devriez voir la ligne
$make =f $makele $target. En supposant que vous êtes en mode débogage, $target sera
probablement dénommé ’debug’ ce qui n’est pas forcément ce que vous voulez. Vous
devriez changer $target par le nom de votre fichier de sortie (avec l’extension .exe et sans
le caractère $ du début).
Un autre ajout utile se trouve dans ’Projet’ →’Arbre des projets’ →’Éditer les types
et catégories de fichiers’ . Si vous y ajoutez makefiles avec le masque *.mak (CB semble
préférer .mak plutôt que .mk) vous serez capables d’ajouter votre makefile avec l’extension
Code::Blocks 117
.mak dans votre projet et il apparaitra dans le panneau de Gestion de projets, sur la
gauche.
En supposant que vous voulez éditer le makefile depuis CB, vous devez vous assurer
que l’éditeur utilise bien des tabulations (plutôt que des espaces). C’est un problème
générique de l’utilitaire make car il a besoin de commencer des lignes de commandes
par un caractère tab alors que de nombreux éditeurs remplacent les tabulations par des
espaces. Pour obtenir cela dans CB, ouvrez la fenêtre ’Paramètres’ →’Éditeur’ et cocher
la case pour utiliser le caractère de tabulation (tab).
Les problèmes réels commencent toutefois maintenant. La génération automatique de CB
ajoute toutes les en-têtes des wxWidgets, mais si vous utilisez un makefile, tout cela n’est
pas fait et vous aurez à le faire vous-même.
Heureusement CB possède une autre fonctionnalité qui peut venir à votre secours. Si
vous allez dans le menu ’Paramètres’ →’Compilateur et Débugueur’ , déplacez les onglets
horizontalement vers la droite, vous trouverez l’onglet ‘autres paramètres’. Là, cliquez sur
la case à cocher ’Enregistrer la génération en HTML ...’. Ceci permettra à CB de créer,
au moment de la génération, un fichier HTML qui enregistrera toutes les commandes de
génération.
Note :
Cette façon de créer un fichier html de génération n’existe plus dans
les versions récentes de CB, mais il y a d’autres solutions
Si vous compilez (sans utiliser un makefile - donc si vous avez déjà tout remis à plat
- désolé) le programme minimal par défaut utilisant wxWidgets, vous pouvez voir les
commandes de compilation et d’édition de liens qui produisent ce fichier.
En supposant que vous allez prendre cela comme base pour votre projet, vous pouvez
utiliser le contenu du fichier HTML produit comme base de votre makefile.
Vous ne pouvez pas simplement le copier depuis le visualiseur HTML de CB (il n’y
a pas cette fonction dans CB) mais vous pouvez charger le fichier dans un navigateur
ou un éditeur, et le copier depuis là. Vous le trouverez dans votre répertoire de pro-
jet avec <le_meme_nom_que_votre_projet>_build_log.HTML. Malheureusement, cela re-
quiert encore quelques ajustements comme montrés ci-dessous.
Voici une copie d’un fichier de génération pour un programme wxWidgets de base tel que
décrit ci-dessus.
Note :
Pour une meilleure lisibilité, les lignes trop longues ont été découpées.
Le signe ^ est le séparateur de ligne en mode DOS, le signe \ est le
séparateur dans le makefile. Mais vous pouvez avoir les commandes
sur une seule ligne à condition d’enlever les séparateurs
Code::Blocks 118
mingw32-make.exe -f test.mak test.exe
mingw32-g++.exe -pipe -mthreads -D__GNUWIN32__ -D__WXMSW__ -DWXUSINGDLL ^

-DwxUSE_UNICODE -Wall -g -D__WXDEBUG__ -IC:\PF\wxWidgets2.8\include ^
-IC:\PF\wxWidgets2.8\contrib\include -IC:\PF\wxWidgets2.8\lib\gcc_dll\mswud ^
-c C:\Development\test\testApp.cpp -o obj\Debug\testApp.o
mingw32-g++.exe -pipe -mthreads -D__GNUWIN32__ -D__WXMSW__ -DWXUSINGDLL ^

-DwxUSE_UNICODE -Wall -g -D__WXDEBUG__ -IC:\PF\wxWidgets2.8\include ^
-IC:\PF\wxWidgets2.8\contrib\include -IC:\PF\wxWidgets2.8\lib\gcc_dll\mswud ^
-c C:\Development\test\testMain.cpp -o obj\Debug\testMain.o
windres -IC:\PF\wxWidgets2.8\include -IC:\PF\wxWidgets2.8\contrib\include ^

-IC:\PF\wxWidgets2.8\lib\gcc_dll\mswud -iC:\Development\test\resource.rc ^
-o obj\Debug\resource.coff
mingw32-g++.exe -LC:\PF\wxWidgets2.8\lib\gcc_dll -o bin\Debug\test.exe ^

obj\Debug\testApp.o obj\Debug\testMain.o obj\Debug\resource.coff ^
-lwxmsw28ud -mwindows
Process terminated with status 0 (0 minutes, 12 seconds)

0 errors, 0 warnings
Le code ci-dessus peut être converti en un makefile ci-dessous. Il est resté délibérément
assez proche de la sortie du fichier HTML.
# test program makefile
Incpath1 = C:\PF\wxWidgets2.8\include
Incpath2 = C:\PF\wxWidgets2.8\contrib\include
Incpath3 = C:\PF\wxWidgets2.8\lib\gcc_dll\mswud
Libpath = C:\PF\wxWidgets2.8\lib\gcc_dll
flags = -pipe -mthreads -D__GNUWIN32__ -D__WXMSW__ -DWXUSINGDLL \

-DwxUSE_UNICODE -Wall -g -D__WXDEBUG__
CXX = mingw32-g++.exe
test.exe : obj\Debug\testApp.o obj\Debug\testMain.o obj\Debug\resource.coff

$(CXX) -L$(Libpath) -o bin\Debug\test.exe obj\Debug\testApp.o \
obj\Debug\testMain.o obj\Debug\resource.coff -lwxmsw28ud -mwindows
obj\Debug\testMain.o : C:\Development\test\testMain.cpp
$(CXX) $(flags) -I$(Incpath1) -I$(Incpath2) -I$(Incpath3) \
-c C:\Development\test\testMain.cpp -o obj\Debug\testMain.o
Code::Blocks 119
obj\Debug\testApp.o : C:\Development\test\testApp.cpp
$(CXX) $(flags) -I$(Incpath1) -I$(Incpath2) -I$(Incpath3) \
-c C:\Development\test\testApp.cpp -o obj\Debug\testApp.o
obj\Debug\resource.coff : C:\Development\test\resource.rc
windres -I$(Incpath1) -I$(Incpath2) -I$(Incpath3) \
-iC:\Development\test\resource.rc -oobj\Debug\resource.coff
# original output from codeblocks compilation

# note I’ve had to add compiling the .res file
#
# mingw32-g++.exe -pipe -mthreads -D__GNUWIN32__ -D__WXMSW__ -DWXUSINGDLL ^
# -DwxUSE_UNICODE -Wall -Wall -g -D__WXDEBUG__ ^
# -Wall -g -IC:\PF\wxWidgets2.8\include -IC:\PF\wxWidgets2.8\contrib\include ^
# -IC:\PF\wxWidgets2.8\lib\gcc_dll\mswud ^
# -c C:\Development\test\testApp.cpp -o obj\Debug\testApp.o
# mingw32-g++.exe -pipe -mthreads -D__GNUWIN32__ -D__WXMSW__ -DWXUSINGDLL ^

# -DwxUSE_UNICODE -Wall -Wall -g -D__WXDEBUG__ ^
# -Wall -g -IC:\PF\wxWidgets2.8\include -IC:\PF\wxWidgets2.8\contrib\include ^
# -IC:\PF\wxWidgets2.8\lib\gcc_dll\mswud ^
# -c C:\Development\test\testMain.cpp -o obj\Debug\testMain.o
# mingw32-g++.exe -LC:\PF\wxWidgets2.8\lib\gcc_dll -o bin\Debug\test.exe ^

# obj\Debug\testApp.o obj\Debug\testMain.o ^
# obj\Debug\resource.res -lwxmsw28ud -mwindows
J’ai écrit un makefile générique que je n’ai testé que sous Windows Vista mais qui devrait
fonctionner sur tout projet commencé comme décrit ci-dessus. Vous devrez changer le
nom du projet et ajuster les chemins appropriés (vous n’aurez probablement qu’à changer
Ppath et WXpath).
# Generic program makefile

# -- assumes that you name your directory with same name as the project file
# -- eg project test is in <development path>\test\
# Project name and version

Proj := test
Version := Debug
#paths for Project (Ppath) Object files (Opath) and binary path (Bpath)
Ppath := C:\Development\$(Proj)
Opath := obj\$(Version)
Bpath := bin\$(Version)
Code::Blocks 120
#Library & header paths

WXpath := C:\PF\wxWidgets2.8
IncWX := $(WXpath)\include
IncCON := $(WXpath)\contrib\include
IncMSW := $(WXpath)\lib\gcc_dll\mswud
Libpath := $(WXpath)\lib\gcc_dll
flags = -pipe -mthreads -D__GNUWIN32__ -D__WXMSW__ -DWXUSINGDLL -DwxUSE_UNICODE \

-Wall -g -D__WXDEBUG__
CXX = mingw32-g++.exe
Obj := $(Opath)\$(Proj)App.o $(Opath)\$(Proj)Main.o $(Opath)\resource.coff
$(Proj).exe : $(Obj)
$(CXX) -L$(Libpath) -o $(Bpath)\$(Proj).exe $(Obj) -lwxmsw28ud -mwindows
$(Opath)\$(Proj)Main.o : $(Ppath)\$(Proj)Main.cpp
$(CXX) $(flags) -I$(IncWX) -I$(IncCON) -I$(IncMSW) -c $^ -o $@
$(Opath)\$(Proj)App.o : C:\Development\$(Proj)\$(Proj)App.cpp
$(CXX) $(flags) -I$(IncWX) -I$(IncCON) -I$(IncMSW) -c $^ -o $@
$(Opath)\resource.coff : C:\Development\$(Proj)\resource.rc
windres -I$(IncWX) -I$(IncCON) -I$(IncMSW) -i$^ -o $@
.PHONEY : clean
clean:
del $(Bpath)\$(Proj).exe $(Obj) $(Opath)\resource.coff
Note :
Exporter un makefile depuis un projet Code::Blocks est possible in-
directement. Vous pouvez l’obtenir à partir de l’utilitaire cbp2make
(voir sa description dans section 4.6 à la page 122 et/ou un exemple
d’utilisation via Tool+ sous-section 2.17.1 à la page 74.
Une dernière remarque. Une fois que vous avez utilisé un makefile, toute tentative de
compiler sans un makefile vous produira de nombreux warnings. La seule façon que j’ai
trouvée pour résoudre cela est de réinstaller CB. Si vous avez besoin des deux façons de
compiler il est possible d’installer 2 versions de CB.
Note :
C’est une remarque du texte original dans le Wiki. Mais, en tant
qu’utilisateur gd on, je n’ai jamais observé ce comportement
Code::Blocks 121
Code::Blocks V2.0.1 beta 4.6 Utilitaire Cbp2make
En général, il n’est pas recommandé d’utiliser un makefile, mais s’il y a de bonnes raisons
de le faire, alors vous avez ici ce qu’il faut.
4.5.2 Compléments
Par défaut, Code::Blocks génère une cible ”Release” et une cible ”Debug”. Dans votre
Makefile, ces cibles peuvent ne pas être présentes. Mais vous avez peut-être une cible
”All” (ou ”all”). Vous pouvez renommer la cible dans Code::Blocks (ou en ajouter une)
par ce nom qui a été donné dans le Makefile.
De plus, votre Makefile génère un exécutable avec un nom spécifique et dans un répertoire
spécifique. Dans Code::Blocks vous devriez ajuster le chemin et le nom de l’exécutable.
Ainsi, Code::Blocks, comme il ne connait ni n’analyse le Makefile, trouvera l’exécutable,
et la flèche verte d’exécution dans le menu fonctionnera (ou Ctrl-F10).
4.6 Utilitaire Cbp2make

Un outil de génération de Makefile pour l’IDE Code::Blocks par Mirai Computing. Le
texte de cette section provient de son Wiki de cbp2make sur SourceForge.
Note :
Cbp2make n’est pas une extension de Code::Blocks, mais une ap-
plication console autonome, placée dans le répertoire principal de
Code::Blocks, et qui génère un (ou des) makefile(s) à partir du système
de génération interne de Code::Blocks
4.6.1 À propos
”cbp2make” est un outil autonome qui vous permet de générer un (ou des) makefile(s)
pour les utiliser via le Make de GNU et en externe aux projets ou aux espaces de travail
de l’IDE Code::Blocks. (Voir aussi http://forums.codeblocks.org/index.php/topic,
13675.0.html])
4.6.2 Utilisation
Création d’un makefile pour un projet unique ou un espace de travail
Supposons que vous ayez un projet ”mon projet.cbp” et que vous ayez besoin d’un makefile
pour ce projet. Dans le cas le plus simple, tout ce que vous avez à faire c’est :
cbp2make = i n m o n p r o j e t . cbp
La même chose s’applique pour les espaces de travail.

cbp2make = i n m e s p r o j e t s . workspace
Création d’un makefile avec un autre nom de fichier

Par défaut, ”cbp2make” ajoutera l’extension ”.mak” au nom du projet pour composer le
nom de fichier du makefile. Si vous voulez change çà, utilisez la commande suivante :
Code::Blocks 122
cbp2make = l s t l i s t i n g m o n p r o j e t . cbp = out M a k e f i l e
Création d’un makefile pour une autre plateforme

Si vous travaillez sous GNU/Linux et que vous voulez générer un makefile pour Windows
ou toute autre combinaison, vous pouvez spécifier la ou les plateformes pour lesquelles
vous avez besoin de ces makefiles.
cbp2make =i n mon p r o j e t . cbp =windows
cbp2make =i n mon p r o j e t . cbp = unix
cbp2make =i n mon p r o j e t . cbp = unix =windows =mac
cbp2make =i n mon p r o j e t . cbp == a l l =o s
”cbp2make” ajoutera le suffixe ”.unix” ou ”.windows” ou ”.mac” au nom du makefile

pour chacune des plateformes respectivement.
Création de makefile pour des projets ou espaces de travail multiples
Si vous avez plus d’un projet ou espace de travail indépendants, vous pouvez les traiter
tous à la fois, en ayant recours à un fichier de texte contenant la liste des projets, par ex.,
”projets.lst”, avec un seul nom de projet par ligne.
m o n p r o j e t . cbp
m o n a u t r e p r o j e t . cbp
Vous pouvez alors les traiter par la commande :

cbp2make = l i s t = i n p r o j e t s . l s t
4.6.3 Configuration
Quelques options spécifiques d’installation ou spécifiques de projet, essentiellement des
configurations d’outils, peuvent être enregistrées dans un fichier de configuration. Par
défaut (depuis la rev.110 ), cbp2make n’enregistre aucun paramètre dans un fichier de
configuration sauf si l’utilisateur spécifie explicitement l’option "==cong". Un fichier de
configuration peut être soit global (enregistré dans le profil utilisateur / répertoire home)
soit local (enregistré dans le répertoire courant).
SVP, gardez à l’esprit que comme cbp2make est encore à un stade de développement
précoce, un ancien fichier de configuration peut devenir incompatible avec la nouvelle
version de l’outil et il pourrait être nécessaire de le mettre à jour à la main ou d’en
initialiser un nouveau.
Initialisation
cbp2make == c o n f i g o p t i o n s == g l o b a l
cbp2make == c o n f i g o p t i o n s == l o c a l
Utilisation suivante
Lorsqu’on invoque cbp2make, il commence par essayer de charger un fichier de configura-
tion local. S’il n’y a pas de fichier de configuration local, il tentera d’en charger un global.
Code::Blocks 123
Si ces tentatives échouent, la configuration construite en interne est alors utilisée. L’ordre
de consultation des configurations peut se changer par les options en ligne de commande
"==local" ou "==global". Si une des options est fournie à cbp2make, la configuration
non-spécifiée ne sera pas tentée même si celle spécifiée est absente et que la non-spécifiée
existe.
Ordre de consultation par défaut
cbp2make = i n p r o j e c t . cbp = out M a k e f i l e }
Configuration spécifiée explicitement

cbp2make == l o c a l = i n p r o j e c t . cbp = out M a k e f i l e
cbp2make == g l o b a l = i n p r o j e c t . cbp = out M a k e f i l e
4.6.4 Syntaxe de la Ligne de Commande

Génération de makefile :
cbp2make -in <project_file> [-cfg <configuration>] [-out <makefile>]

[-unix] [-windows] [-mac] [--all-os] [-targets "<target1>[,<target2>[, ...]]"]
[--flat-objects] [--flat-objpath] [--wrap-objects] [--wrap-options]
[--with-deps] [--keep-objdir] [--keep-outdir] [--target-case keep|lower|upper]
cbp2make -list -in <project_file_list> [-cfg <configuration>]

[-unix] [-windows] [-mac] [--all-os] [-targets "<target1>[,<target2>[, ...]]"]
[--flat-objects] [--flat-objpath] [--wrap-objects] [--wrap-options]
[--with-deps] [--keep-objdir] [--keep-outdir] [--target-case keep|lower|upper]
Gestion des outils :
cbp2make --config toolchain --add \[-unix|-windows|-mac\] -chain <toolchain>

cbp2make --config toolchain --remove \[-unix|-windows|-mac\] -chain <toolchain>
Gestion des outils de génération :
cbp2make --config tool --add \[-unix|-windows|-mac\] -chain <toolchain>

-tool <tool> -type <type> <tool options>
cbp2make --config tool --remove \[-unix|-windows|-mac\] -chain <toolchain>

-tool <tool>
Types d’outils :
pp=preprocessor as=assembler cc=compiler rc=resource compiler

sl=static linker dl=dynamic linker el=executable linker
nl=native linker
Code::Blocks 124
Options des outils (communes) :
-desc <description> -program <executable> -command <command_template>

-mkv <make_variable> -srcext <source_extensions> -outext <output_extension>
-quotepath <yes|no> -fullpath <yes|no> -unixpath <yes|no>
Options des outils (compilateur) :
-incsw <include_switch> -defsw <define_switch> -deps <yes|no>
Options des outils (éditeur de liens):
-ldsw <library_dir_switch> -llsw <link_library_switch> -lpfx <library_prefix>

-lext <library_extension> -objext <object_extension> -lflat <yes|no>
Gestion des plateformes :
cbp2make --config platform \[-unix|-windows|-mac\] \[-pwd <print_dir_command>\]

\[-cd <change_dir_command>\] \[-rm <remove_file_command>\]
\[-rmf <remove_file_forced>\] \[-rmd <remove_dir_command>\]
\[-cp <copy_file_command>\] \[-mv <move_file_command>\]
\[-md <make_dir_command>\] \[-mdf <make_dir_forced>\]
\[-make <default_make_tool>\]
Gestion des variables globales du compilateur :
cbp2make --config variable --add \[-set <set_name>\] -name <var_name>

\[-desc <description>\] \[-field <field_name>\] -value <var_value>
cbp2make --config variable --remove \[-set <set_name>\] \[-name <var_name>\]

\[-field <field_name>\]
Options de gestion :
cbp2make --config options --default-options "<options>"

cbp2make --config show
Options communes :
cbp2make --local // utilise la configuration du répertoire courant

cbp2make --global // utilise la configuration du répertoire home
cbp2make --verbose // affiche les informations du projet
cbp2make --quiet // masque tous les messages
cbp2make --help // affiche ce message
cbp2make --version // affiche l’information de version
Code::Blocks 125
Options
"Génération de Makefile"
-in <project_file> // spécifie un fichier d’entrée ou une liste de fichiers;
-cfg <configuration> // spécifie un fichier de configuration, voir aussi les

options "--local" et "--global";
-out <makefile> // spécifie le nom d’un makefile ou une liste de

makefiles;
-unix // active la génération de makefile compatibles Unix/Linux;
-windows // active la génération de makefile compatibles Windows;
-mac // active la génération de makefile compatibles Macintosh;
--all-os // active la génération de makefile sur toutes les cibles

à la fois;
-targets "<target1>[,<target2>[, ...]]" // spécifie la seule cible de génération

pourlaquelle un makefile doit e ^tre
généré;
--flat-objects // force les noms "flat" pour les fichiers objets avec un
"character set" limité;
--flat-objpath // force les noms de chemins "flat" pour les fichiers objets
sans sous-répertoires;
--wrap-objects // permet l’utilisation de liste d’objets sur plusieurs

lignes ce qui rend un makefile plus facile à lire;
--wrap-options // permet l’utilisation de macros sur plusieurs lignes;
--with-deps // permet d’utiliser le scanner interne des dépendances

pour les projets C/C++;
--keep-objdir // désactive la commande qui supprime les répertoires des

fichiers objets dans la cible ’clean’;
--keep-outdir // désactive la commande qui supprime le répertoire de

sortie des fichiers binaires dans la cible ’clean’;
--target-case [keep|lower|upper] // spécifie un style pour les cibles de

makefile;
Code::Blocks 126
Code::Blocks V2.0.1 beta 4.7 Internationalisation de l’interface de Code::Blocks
4.7 Internationalisation de l’interface de Code::Blocks

Cette section décrit comment obtenir et utiliser une version internationalisée de Code::Blocks.
L’interface de Code::Blocks peut être affichée dans votre propre langue. La plupart des
chaı̂nes de caractères utilisée en interne pour l’interface de Code::Blocks sont introduites
par une macro wxWidgets : (). Les chaı̂nes qui ne changent pas avec la langue sont nor-
malement introduites par la macro wxT() ou T(). Pour obtenir l’interface de Code::Blocks
affichée dans votre propre langue, vous devez simplement dire à Code::Blocks qu’un fichier
de langue est disponible. Pour être compréhensible par Code::Blocks, ce doit être un fichier
.mo obtenu après ”compilation” d’un fichier .po. De tels fichiers sont disponibles sur le
forum pour le ”Français” et sur le site web Launchpad pour un plus large ensemble de
langues.
Le site original sur Launchpad est maintenant obsolète : https://launchpad.net/
codeblocks
Le sujet du forum traitant de la traduction est http://forums.codeblocks.org/index.
php/topic,1022.0.html. Vous pourrez aussi y trouver des outils d’extraction des
chaı̂nes de caractères des fichiers sources de Code::Blocks si cela vous intéresse. Ces
outils créent un fichier .pot qu’il suffit ensuite de compléter par les traductions afin
d’en créer un fichier .po.
Un nouveau site web a été créé récemment sur https://launchpad.net/codeblocks-gd.
Il contient plus de 9300 chaı̂nes de caractères alors que l’original n’en avait que 2173!
Beaucoup de travail a été fait sur Code::Blocks!
Dans la page ”translation” choisissez ”View All languages”, en bas, à droite.
Les anciennes traductions ont été importées dans cette nouvelle page, seulement les
langues les plus utilisées (actuellement 14 langues). Sur demande, on peut ajouter des
langues (mais les traducteurs auront un peu plus de travail !).
Désolé de cela, mais les noms des traducteurs d’origine ont été perdus dans la plupart des
cas :-[.
C’est la langue Française qui a le plus grand nombre de chaı̂nes traduites. Le modèle
(fichier .pot) a été mis à jour sur les versions svn récentes et Launchpad contient le tra-
vail de traduction effectué jusqu’à présent. Pour la langue Russe, on a aussi utilisé une
page web assez récente mais pas tout à fait à jour. Pas mal de traductions doivent être
approuvées, mais je ne suis pas le bon interlocuteur pour ça !
La page launchpad est ouverte en tant que ”structured”. Donc, vous êtes en mesure de
proposer de nouvelles traductions, ou d’en corriger. Dans certains cas, elles devront être
approuvées par quelqu’un d’autre avant sa publication.
J’essaierai de maintenir le ”modèle” lorsque de nouvelles chaı̂nes en Anglais seront disponibles.
Vous (les traducteurs) devriez être capables de participer. Vous devez seulement posséder
(ou créer) un compte launchpad (Ubuntu).
Les autres utilisateurs peuvent demander à télécharger le fichier .po ou .mo. C’est ce
dernier (le fichier .mo), la forme binaire, que vous pouvez utiliser pour avoir l’interface
de Code::Blocks dans votre propre langue : placez le simplement dans votre ”répertoire
Code::Blocks 127
d’installation de codeblocks”/share/CodeBlocks/locale/”language string” (pour moi, sous

Windows, c’est
C:\Program Files\CodeBlocks wx313 64\share\CodeBlocks\locale\fr FR. Ensuite dans
le menu Paramètres/Environnement.../Vue vous devriez être capable de choisir la langue.
Quelques détails complémentaires pour utiliser les chaı̂nes traduites dans Code::Blocks.
Pour les utilisateurs de traductions seulement :
Téléchargez le fichier au format .mo via la bouton le ”requested language”. Le nom re-
tourné par launchpad peut être quelque chose comme : de LC MESSAGES All codeblocks.mo
(ici pour de l’allemand).
Vous devriez mettre ce fichier dans votre répertoire d’installation de codeblocks.
Sous Windows, c’est quelque chose comme :
C:\Program Files (x86)\CodeBlocks\share\CodeBlocks\locale\xxxx pour une ver-
sion 32 bits
ou
C:\Program Files\CodeBlocks\share\CodeBlocks\locale\xxxx pour une version 64
bits.
Les chemins sous Linux sont assez semblables.
xxxx doit être adapté à votre langue. C’est :
de DE pour l’Allemand,
es ES pour l’Espagnol,
fr FR pour le Français,
it IT pour l’Italien,
lt LT pour le Lithuanien,
nl NL pour le Hollandais,
pl PL pour le Polonais,
pt BR pour le Portugais brésilien,
pt PT pour le Portugais ,
ru RU pour le Russe,
si pour le Cingalais,
zh CN pour le chinois simplifié,
zh TW pour le chinois traditionnel.
Créez, si besoin, les sous-répertoires. Puis placez-y votre fichier .mo. Vous pouvez garder
le nom du fichier tel que, ou ne garder que les premières lettres (c’est comme vous voulez),
mais conservez l’extension .mo.
Code::Blocks 128
Puis démarrez Code::Blocks. Dans Paramètres/Environnement/Vue vous devez pouvoir

cocher la case de la langue (internationalization) puis choisissez votre langue. Si ça ne
marche pas, c’est que vous avez probablement oublié quelque chose ou fait une erreur.
Redémarrez Code::Blocks pour activer la nouvelle langue.
Si vous voulez retourner à l’anglais, décochez tout simplement la case du choix de la
langue.
Pour les traducteurs :
Vous pouvez travailler directement dans launchpad.
Problème : l’interface n’est pas très conviviale.
Vous pouvez aussi télécharger le fichier .po, travailler dessus avec poedit par exemple
(la version gratuite suffit). Vous pouvez tester vos traductions en local en la compilant
(création d’un fichier .mo) puis en installant ce fichier .mo dans le sous-répertoire adéquat
de Code::Blocks.
Quand vous aurez suffisamment avancé (c’est votre décision), vous pourrez envoyer (”up-
load”) le fichier .po dans launchpad. Il peut être nécessaire que votre travail soit approuvé
ou de le marquer comme à revoir (”to be reviewed”).
Ne soyez pas effrayé : c’est un travail assez long. Sur l’ancien site, il y avait 2173 chaı̂nes à
traduire. Maintenant il y en a plus de 9300 ! Mais le travail peut être partagé, Launchpad
est fait pour ça !
Astuce : Commencez par des menus que vous utilisez souvent : vous verrez les progrès
plus vite.
Code::Blocks 129
5 Installation et Configuration de CodeBlocks
avec MinGW
Ce chapitre décrit comment installer et configurer Code::Blocks. Le processus d’installation
est ici décrit pour Windows, mais peut être adapté aux autres OS.
5.1 Installation de la dernière version officielle de

Code::Blocks sous Windows
Étapes d’installation :
Télécharger l’installateur de Code::Blocks (https://codeblocks.org/downloads/
26). Si vous n’avez pas MinGW d’installé, ou si vous ne savez pas lequel choisir,
télécharger la version qui intègre MinGW. Pour une version 20.03, le nom
de l’installateur est : codeblocks-20.03mingw-setup.exe. La version précédente était
identifiée par 17.12.
Lancez l’installateur. C’est un installateur standard pour Windows ; pressez seule-
ment sur Next (ou Suivant) après avoir lu chaque écran.
Si vous prévoyez d’installer un compilateur après avoir installé Code::Blocks, lisez
les informations données dans l’installateur.
Si vous avez téléchargé un installateur qui n’intègre pas MinGW, vous devrez cer-
tainement configurer manuellement le compilateur (souvent Code::Blocks détecte
tout seul le compilateur).
Nous verrons dans la section suivante comment installer et configurer un autre compila-
teur.
Notes:
Le fichier codeblocks-20.03-setup.exe inclut Code::Blocks avec toutes les extensions.
Le fichier codeblocks-20.03-setup-nonadmin.exe est fourni par commodité aux util-
isateurs qui n’ont pas les droits d’administrateur sur leur(s) machine(s).
Le fichier codeblocks-20.03mingw-setup.exe inclut en plus un compilateur GCC/G++
et un débugueur GDB provenant la version MinGW64 8.1.0, 64 bits, seh. Le fichier
codeblocks-20.03mingw fortran-setup.exe inclut de plus un compilateur Gfortran.
Le fichier codeblocks-20.03(mingw)-nosetup.zip est fourni par commodité aux util-
isateurs qui sont allergiques aux installateurs. Toutefois, vous ne pourrez pas choisir
les extensions / fonctionnalités à installer (tout est inclus) ni même créer les rac-
courcis de menu. Pour l’”installation” vous êtes seuls.
Il est possible d’utiliser une version ”nightly” disponible via le Forum. Ces générations
n’ont pas de compilateurs intégrés !! Vous aurez donc besoin d’installer un compila-
teur vous-même (si vous n’en avez pas déjà un). Avant l’installation, SVP jetez un
oeuil sur http://forums.codeblocks.org/index.php/topic,3232.0.html
Code::Blocks V2.0.1 beta 5.2 Configurer MinGW
Une bonne solution, est d’installer une distribution officielle comportant MinGW
puis d’installer par-dessus cette version officielle une ”nightly”. Il vous faudra suivre
la procédure avec attention car car il pourrait y avoir des incompatibilités. Le
mélange de versions apporte des problèmes.
La version complète de Code::Blocks est distribuée avec une version de MinGW en
64 bits incluse dans un sous-répertoire. Parfois, cela peut amener des soucis car le
nom de chemin complet contient un espace (dans Program Files). Une bonne so-
lution consiste à déplacer le répertoire MinGW à la racine de votre disque. Vous
pouvez aussi le renommer en C:\MinGW64. La détection automatique du compila-
teur devrait l’y trouver.
5.2 Configurer MinGW

Cette section décrit comment installer et configurer MinGW.
5.2.1 Généralités
Une chaı̂ne d’outils de compilation est ce que Code::Blocks utilise pour transformer le
code que vous avez tapé en nombres que l’ordinateur peut comprendre. Comme une
chaı̂ne d’outils de compilation est une chose plutôt complexe ce n’est pas une par-
tie intégrante de Code::Blocks mais plutôt un projet séparé que Code::Blocks utilise
alors. Le type d’outils de chaı̂ne de compilation dont il est question dans ces pages est
la chaı̂ne d’outils ”MinGW”. Cela veut dire ”Minimalist GNU for Windows.” Et ”GNU”
peut s’interpréter par ”GNU’s Not Unix.” Davantage d’informations sur le projet GNU
peuvent être trouvées via la page d’accueil de GNU.
Pour la plupart des chaı̂nes d’outils de compilation basées sur MinGW, il est important
d’avoir le chemin de cette chaı̂ne dans votre variable d’environnement PATH car cela
signifie que pendant le développement les librairies seront accessibles par défaut à vos
programmes pendant que vous les développez mais cela rend aussi plus facile l’utilisation
d’utilitaires comme CMake car ils seront capables de trouver votre chaı̂ne d’outils de
compilation. Quand vous distribuez vraiment vos programmes vers d’autres ordinateurs
vous aurez besoin de copier les fichiers .dll nécessaires depuis votre répertoire de chaı̂ne
de compilation et de les intégrer en tant que partie intégrante dans votre installateur. Sur
votre machine elles sont dans votre PATH et donc vous les avez toujours à portée, mais
sur les ordinateurs des autres utilisateurs, ils n’auront peut-être pas cette chaı̂ne d’outils
de compilation, c’est pourquoi vous devrez fournir vos fichier dll avec votre programme.
5.2.2 La chaı̂ne d’outils de compilation MinGW

Vous pouvez trouver sur le web plusieurs distributions de MinGW. Voici une liste non
exhaustive de distributions.
MinGW - Le projet original http://www.mingw.org/: Compilateurs 32 bits seulement;
Distribution TDM http://tdm-gcc.tdragon.net/: 32 et 64 bits, mais une distribution
5.1, maintenant obsolète. Était utilisée et distribuée avec Code::Blocks 17.12;
Code::Blocks 131
Nouvelle distribution TDM http://tdm-gcc.tdragon.net/: basée sur une distribu-

tion 9.2. Semble avoir encore parfois des soucis, du moins pour Code::Blocks lui-
même.
MinGW 64 https://sourceforge.net/projects/mingw-w64/files/: 32 et 64 bits, une
distribution en version 8.1 dans ”Toolchains targetting”. Le projet parent des générations
MinGW-builds, qui inclut bien plus que ce qui est nécessaire - MinGW-Builds suf-
firont pour un usage courant. Plusieurs choix sont proposés : pour un compilateur 32
bits, vous pouvez choisir la version posix, sjlj (i686-posix-sjlj) et pour un compilateur
64 bits vous pouvez choisir la version posix, seh (x86 64-posix-seh) (choix compati-
bles avec ceux de l’ancienne version TDM). C’est cette dernière version 64 bits-posix-
seh qui est utilisée dans les versions nightlies compilées récentes de Code::Blocks et
distribuée avec la version 20.03. Les autres choix fonctionnent également : Cela
dépend de vos besoins. gcc, g++, gfortran, gdb, lto, omp, mingw32-make sont dans
la distribution;
MinGW 64 Ray linn Personal build https://sourceforge.net/projects/mingw-w64/
files/Multilib%20Toolchains%28Targetting%20Win32%20and%20Win64%29/ray_
linn/gcc-9.x-with-ada/: une distribution 64 bits, version 9.1 dans le sous-répertoire
”personnal build”. Utilise les librairies statiques, et dons pas besoin de distribuer
des dlls avec vos propres exécutables, mais ils seront plus gros. ada, gcc, g++, gfor-
tran, lto, objc, obj-c++, omp sont dans la distribution. Problème : gdb et make n’y
sont pas inclus.
MinGW Equation http://www.equation.com/servlet/equation.cmd?fa=fortran: 32
et 64 bits, versions récentes (plusieurs choix). Utilise des librairies statiques, donc,
comme avec la version ci-dessus, produit des exécutables plus gros, mais pas besoin
de distribuer les dlls avec vos propres exécutables. gcc, g++, gfortran, gdb, lto, omp,
make sont dans la distribution;
MinGW LH Mouse version https://gcc-mcf.lhmouse.com/: 32 et 64 bits, versions
récentes (mais pas forcément la toute dernière). Pas de gfortran (?). Modèle de
thread spécial (mcf). gcc, g++, gdb, lto, omp, mingw32-make sont dans la distri-
bution. Pas de gfortran;
MinGW on Winlibs http://winlibs.com/: 64 bits, versions récentes (mais pas forcément
la toute dernière). gcc, g++, gfortran, gdb, lto, objc, obj-c++, omp, mingw32-make
sont dans la distribution;
Msys2 http://www.msys2.org/ and https://packages.msys2.org/group/mingw-w64-x86_
64-toolchain: versions 32 et/ou 64 bits, installées dans C:\msys64\mingw32 et
C:\msys64\mingw64. Contrairement aux installateurs ci-dessus tout-en-un, nécessite
un travail complémentaire pour l’ajuster à vos besoins, vos compilateurs, votre
chaı̂ne d’outils. Lisez attentivement la documentation. Néanmoins, Msys2 fourni
des versions récentes des compilateurs et donne accès à un outil de mise à jour :
pacman. ada, gcc, g++, gfortran, gdb, lto, objc, obj-c++, omp, mingw32-make sont
dans la distribution ou peuvent être installés via pacman;
Code::Blocks 132
5.2.3 Configuration de Code::Blocks

Allez dans vos paramètres du Compilateur :
Figure 5.1: Paramètres des Compilateurs
Puis dans l’onglet ”Programmes” (ou ”Toolchain executables”) (flèche en rouge), cliquez
sur ”...”, (flèche en bleu) et choisissez le répertoire de base où vous avez installé MinGW
(64-bits ici). Une fois que vous avez choisi ce répertoire, dans la sous rubrique ”Fichiers
de Programmes” (flèche en vert) des champs à rempli sont affichés. Si vous n’utilisez
pas une chaı̂ne d’outils MinGW 64-bits, il se peut que des variations mineures soient à
apporter aux noms des exécutables. Si vous avez choisi d’abord le bouton indiqué par la
flèche en bleu, alors pour chacun des boutons suivants vous serez déjà positionnés dans le
sous-répertoire bin de votre MinGW 64-bits où sont placés les programmes.
Figure 5.2: Configuration de la chaine d’outils de Code::Blocks
Code::Blocks 133
Note : Vous pouvez entrer le nom comme gcc.exe ou x86 64-w64-mingw32-gcc.exe ou

mingw32-gcc.exe (cela dépend de la distribution) : c’est en fait le même exécutable. De
même pour g++.
Note :
Pour configurer un nouveau compilateur, gfortran par exemple, entrez
gfortran.exe dans les 3 premiers champs de texte de l’ongle ”Fichiers
Programmes”, ou le nom exact qui est dans votre distribution
Maintenant, allez dans les paramètres du Débugueur :
Figure 5.3: Paramètres du Débugueur
Choisissez votre débugueur par défaut (flèche en rouge), puis remplissez dans le champ
de l’exécutable comme indiqué pour MinGW 64-bits (flèche en bleu).
Code::Blocks 134
Code::Blocks V2.0.1 beta 5.3 Version Nightly de Code::Blocks sous Windows
Figure 5.4: Configuration du Débugueur par Default
Résumé
Vous avez maintenant un environnement de Code::Blocks qui est configuré pour utiliser
correctement MinGW 64-bits. Utilisez ce guide comme un modèle pour configurer d’autres
chaı̂nes d’outils de compilation qu’elle qu’en soit la source - suivez simplement cette
procédure de base.
Outils de Développement
Normalement vous ne devriez pas avoir besoin de ces outils. ZIP est pratique, notamment
pour générer Code::Blocks lui-même, est souvent déjà présent dans MinGW, mais les
autres outils servent seulement dans des cas particuliers.
UnxUtils : différents outils Unix-Like sur https://sourceforge.net/projects/
unxutils/
GnuWin32 : d’autres outils Gnu sur https://sourceforge.net/projects/gnuwin32/
ZIP : 32-bits ou 64-bits sur ftp://ftp.info-zip.org/pub/infozip/win32/ : choi-
sissez plutôt une version zip300xn.
5.3 Version Nightly de Code::Blocks sous Windows

Les générations de ”Nightly” sont distribuées ”telles que”. Ce sont des distributions ”bi-
naires”, normalement fournies au jour le jour, représentant les dernières avancées de l’état
Code::Blocks 135
de l’art des sources de Code::Blocks. En principe, elles sont relativement stables, cepen-
dant elles peuvent aussi introduire de nouveaux bugs, des régressions, mais d’un autre
côté elles peuvent apporter de nouvelles fonctionnalités, des corrections de bugs, ...
Avant de décrire ce que ces générations contiennent, il est important de commencer par
revoir ce que NE SONT PAS les générations ”nightly”. Pour débuter demandez-vous :
qu’est-ce que Code::Blocks?
Bon, c’est un IDE (Integrated Development Environment) soit en français un Environ-
nement de Développement Intégré : cela signifie qu’il intègre différents outils et les fait
travailler ensemble. Donc Code::Blocks n’est PAS un compilateur (ni même MS, ni
Borland), ce n’est pas un débugueur, ce n’est pas non plus un système de génération de
makefile ! Donc, ces composants ne font PAS partie de Code::Blocks, et par conséquent
ne font pas partie de la distribution ”nightly”. Toutefois, plusieurs des composants de
développement mentionnés peuvent être combinés pour travailler harmonieusement en-
semble dans Code::Blocks. Par exemple, vous pouvez y intégrer le compilateur GCC et le
débugueur GDB et ainsi compiler et débuguer vos propres applications.
Code::Blocks est lui-même compilé avec GCC. Sous Windows c’est fait en utilisant le
portage MinGW. Comme Code::Blocks est une application ”multi-threaded” cela nécessite
le support de routines fournissant ces fonctionnalités de ”multi-threading”. C’est ce que
fourni le portage MinGW, et plus particulièrement la librairie ”mingwm10.dll” Dans cha-
cune des annonces d’une nouvelle génération de ”nightly” vous trouverez un lien vers cette
dll. Code::Blocks possède un GUI (Graphical User Interface) ou Interface Graphique Util-
isateur en français. Il existe de nombreuses façons de créer un GUI : vous pouvez le coder
en utilisant le coeur de l’API Windows (ne fonctionne que sous Windows) ou vous pouvez
utiliser MS-MFC (ne fonctionne que sous Windows) ou vous pouvez utiliser une librairie
de GUI tierce, comme QT, wxWidgets, Tk, ...
Code::Blocks utilise wxWidgets. En plus de l’apport GUI, wxWidgets amène bien d’autres
fonctions supplémentaires (manipulation de chaı̂nes, fichiers, flux, sockets, ...) et le meilleur
dans tout ça : wxWidgets apporte ces fonctions pour différentes plateformes (Windows,
Linux, Apple, ...). Cela veut dire qu’il faut que Code::Blocks intègre les fonctionnalités de
wxWidgets (à savoir le code binaire qui effectue le réel travail). C’est ce qui est obtenu
via une dll : ”wxmsw31u gcc cb.dll” (17.12 était basé sur ”wxmsw28u gcc cb.dll”). Une
fois de plus, sur chaque annonce de génération ”nightly” vous trouverez un lien vers cette
dll ainsi que d’autres prérequis.
Quand, sous Windows, vous installez une version officielle incluant MinGW (la version
recommandée), vous trouverez un répertoire MinGW dans C:\Program Files\codeblocks.
Si cela marche bien ici dans la plupart des cas, ce n’est pas le meilleur endroit pour le
mettre, entre autre parce qu’il y a un espace à l’intérieur du nom du chemin d’accès et
que cet espace peut troubler certains des composants de MinGW. Alors, sous Windows,
déplacez de répertoire MinGW vers C:, par exemple. Vous pouvez même le renommer
MinGW32 pour une chaı̂ne d’outils de compilation en 32 bits, ou MinGW64 pour une
chaı̂ne en 64 bits.
Comme dit précédemment, une bonne solution pour installer une version ”nightly” est
de commencer par installer une version officielle, puis de la configurer et l’essayer.
Ainsi, vos fichiers de configuration, associations, raccourcis clavier, seront correctement
paramétrés et ils seront conservés lors de l’installation de la ”nightly”. Le lien pour trouver
Code::Blocks 136
les dernières “nightlies“ est http://forums.codeblocks.org/index.php/board,20.0.

html.
Si vous installez votre ”nightly” par-dessus une version 20.03, vous devez suivre avec
attention la procédure car un certain nombre de choses ont changé, notamment, elles sont
compilées en 64 bits avec un compilateur récent, une version différente de wxWidgets et
ont besoin de dlls complémentaires.
Normallement, vous ne devriez pas avoir ce type de problèmes avec une version 20.03.
Dézippez la version ”nightly” téléchargée et copiez tous les fichiers dans votre sous-
répertoire codeblocks. Si vous avez déplacé votre sous-répertoire MinGW ailleurs,
vous pouvez même d’abord effacer tout le contenu de ce sous-répertoire codeblocks
pour être certain de ne pas mélanger les versions. Une exception : si vous avez installé
dans ce sous-répertoire des choses particulières, comme par exemple des fichiers de
localisation, ne les effacez pas.
Dézippez les dlls wxWidgets trouvées avec votre nightly. Vous pouvez les installer di-
rectement dans votre sous-répertoire codeblocks ou pour une utilisation plus étendue,
dans le sous-répertoire bin de MinGW. Vérifiez que ce sous-répertoire bin est bien
dans votre PATH. Il devrait l’être si vous avez installé une version officielle de CB
via l’installateur.
Dézippez les dlls pré-requises. Vous pouvez les installer directement dans votre sous-
répertoire codeblocks. Ici également, pour une utilisation plus étendue, vous pouvez
les installer dans le sous-répertoire bin de MinGW ou tout autre chemin accessi-
ble via votre variable PATH. Mais faites attention, car elles peuvent déjà y être
présentes, mais dans une version différente, ou compilées par une autre version de
MinGW. Dans ce cas, il vaut mieux les garder dans le sous-répertoire codeblocks,
pour un usage privé et pour éviter des soucis liés au mélange de versions de MinGW.
Note :
Les dlls de wxWidgets et celles pré-requises ne changent pas très sou-
vent. Donc, si vous installez une ”nightly” par-dessus une précédente,
il n’est pas forcément nécessaire de les mettre à jour. Lisez avec at-
tention le sujet du forum concernant spécifiquement cette ”nightly”.
Normalement, c’est tout. Votre ”nightly” est prête à l’emploi ...
Code::Blocks 137
6 Générer CodeBlocks à partir des Sources
Ce chapitre décrit comment générer Code::Blocks lui-même.
Note :
Ce chapitre existait dans les fichiers originaux .tex de la version 1
mais n’a pas été publié dans toutes les langues. Il est nécessaire de le
revoir et de le compléter, au moins pour les utilisateurs Linux.
6.1 Introduction
Cette section décrit le processus de création des nightly builds (générations nocturnes !),
et peut être utilisé comme un guide si vous voulez générer Code::Blocks vous-même. La
description suivante est une séquence d’actions.
Afin de procéder à notre tâche de génération, nous aurons besoin de plusieurs outils.
Créons d’abord une liste d’ingrédients pour notre recette de cuisine.
un compilateur
un système de génération initial (une version précédente déjà fonctionnelle)
les sources de Code::Blocks
un programme zip
svn (système de contrôle de versions)
wxWidgets
6.2 Windows ou Linux

Cette section est écrite avec une syntaxe Windows mais peut facilement être adaptée à
Linux. D’autres instructions détaillées se trouvent dans le Wiki : http://wiki.codeblocks.
org/index.php/Installing_Code::Blocks_from_source_on_Linux
Comme les développeurs de Code::Blocks génèrent Code::Blocks en utilisant GCC, nous
ferons de même sous Windows. Le portage le plus facile et le plus propre est MinGW.
C’est le compilateur distribué avec Code::Blocks quand vous téléchargez le package officiel
COMPLET. Avec C::B 17.12, c’était la version TDM 5.1.0 qui était distribuée, une version
déjà ancienne. Ici, on s’en tiendra à la version 8.1.0, qui fonctionne bien et qui est main-
tenant distribuée avec Code::Blocks 20.03, mais on en trouve de plus récentes (Comme vu
dans La chaı̂ne d’outils de compilation MinGW (sous-section 5.2.2 à la page 131). Vous
pouvez obtenir 2 versions différentes de MinGW : pour générer du code 32 bits, ou pour
générer du code 64 bits sur [,→MinGW64]. Plusieurs sous-choix sont possibles. Pour du
32 bits, je suggérerais i686-posix-sjlj et pour du 64 bits x86 64-posix-seh.
Code::Blocks V2.0.1 beta 6.2 Windows ou Linux
Note :
La version MinGW 64 bits peut générer du code 64 bits et du code
32 bits. Ajoutez simplement l’option -m64 ou -m32 à vos options de
compilation ET d’édition de liens. En principe, la version 32 bits ne
génère que du code 32 bits. Faites juste attention si vous utilisez des
librairies, statiques ou dynamiques, à ce qu’elles aient été générées
avec le même nombre de bits
D’abord, une brève explication des composants de MinGW :

gcc-core le coeur de la suite GCC
gcc-g++ les compilateurs c et c++
gfortran le compilateur fortran. IMPORTANT : gfortran 5.1 a un bug : l’instruction open,
pour ouvrir un fichier de données en lecture, ne fonctionne pas ! Malheureusement,
la dernière distribution TDM utilise ce gfortran et n’a pas été mise à jour.
mingw Runtime l’implémentation des librairies ”run time”
mingw utils plusieurs utilitaires (implémentation de petits programmes que GCC utilise
lui-même)
win32Api l’API (Interface de Programmation d’Application) pour créer des programmes
Windows
binutils plusieurs utilitaires utilisés dans l’environnement de génération
make le programme make de Gnu, ainsi vous pouvez générer à partir de fichiers make
GDB le débogueur Gnu
Je vous suggère d’extraire (et d’installer pour GDB si nécessaire) le tout dans un répertoire
C:\MinGW. Le reste de cet article supposera que c’est là que vous l’avez mis. Si vous avez
déjà une installation de Code::Blocks qui a été fournie avec MinGW, je vous recommande
malgré tout d’installer MinGW comme décrit ici. Un compilateur n’a pas à être dans
l’arborescence d’un Environnement de Développement Intégré (IDE); ce sont deux choses
bien distinctes. Code::Blocks le fournit avec les versions officielles afin que l’utilisateur
standard n’ait pas à se préoccuper de ce genre de choses. Néanmoins, certains outils issus
du monde Unix ont des problèmes quand ils sont installés dans un chemin contenant
des espaces (ou même des caractères accentués) dans le nom de sous-répertoires. Pour
une utilisation simple de C::B, vous n’aurez pas de soucis, mais cela peut arriver, aussi
n’hésitez pas à déplacer votre C:\Program Files\Codeblocks\MinGW vers quelque chose
comme C:\MinGW.
Vous pouvez avoir besoin d’ajouter le répertoire bin de votre installation MinGW (et/ou
MinGW32/MinGW64) à votre variable path. Un moyen simple de faire cela est d’entrer
la commande suivante dans une fenêtre DOS :
set path=%PATH%;C:\MinGW32\bin;C:\MinGW32\i686-w64-mingw32\bin;
Code::Blocks 139
ou (pour une installation en 64 bits) :
set path=%PATH%;C:\MinGW64\bin;C:\MinGW64\x86_64-w64-mingw32\bin;
C’est nécessaire pour lancer votre exécutable en dehors du contexte de l’IDE Code::Blocks.
Vous pouvez aussi modifier la variable d’environnement PATH (globale ou utilisateur).
6.2.1 Système de génération initial

Sur [,→CODEBLOCKS] un fichier de description de projet CodeBlocks.cbp est disponible.
Si vous chargez ce fichier dans Code::Blocks alors vous êtes en mesure de générer Code::Blocks
à partir des sources. Tout ce dont vous avez besoin c’est d’une version de Code::Blocks
déjà pré-générée.
Premièrement, téléchargez une version ”nightly”. Vous pouvez faire votre sélection à par-
tir de là ([,→FORUM] rubrique Nightly Builds). Les versions nightly sont des versions
Unicode, contenant le coeur et les plugins contributifs. Lisez avec attention le premier
”post” de chaque ”nightly” : il contient des instructions pour télécharger et installer des
dlls complémentaires, nécessaires avec les versions récentes de MinGW, en particulier la
8.1 utilisée pour compiler les dernières versions ”nightly” de C::B.
Ensuite, décompressez le fichier 7-zip dans n’importe quel répertoire de votre choix. Si
vous n’avez pas 7-zip, vous pouvez le télécharger gratuitement depuis [,→7Z].
Maintenant, Code::Blocks nécessite une dll supplémentaire pour travailler correctement:
la dll wxWidgets. Vous pouvez aussi la télécharger depuis le forum des nightly builds.
Dézippez là simplement dans le même répertoire que celui où vous avez décompressé la
version nightly de Code::Blocks. Il vous faut aussi la dll mingwm10.dll. Elle est nor-
malement dans le répertoire bin de votre installation de MinGW. C’est pourquoi il est
important de s’assurer que le sous répertoire bin de votre installation MinGW est bien
dans votre variable path.
Enfin, démarrer cette nouvelle génération d’une ”nightly” de Code::Blocks. Elle devrait
trouver le compilateur MinGW qui vient d’être installé. Si ce n’est pas le cas, allez dans
le menu ”Paramètres / Compilateur... / Programmes” et ajustez le chemin de MinGW
en fonction de votre installation.
6.2.2 Système de Contrôle de Versions

Afin de pouvoir récupérer les dernières sources de Code::Blocks, nous avons besoin d’installer
un système de contrôle de versions.
Les développeurs de Code::Blocks fournissent leurs sources par le biais du système de
contrôle de versions [,→Subversion]. Aussi, nous avons besoin d’un client pour accéder
à leur dépôt svn des sources. [,→TortoiseSVN] est un bon client pour Windows, facile
d’utilisation, et qui est disponible gratuitement. Téléchargez-le et installez-le, en gardant
tous les paramètres suggérés.
Code::Blocks 140
Maintenant, créez un répertoire où vous voulez, par exemple D:\projets\CodeBlocks.

Faites un clic droit dans ce répertoire et choisissez dans le menu popup : svn-checkout (ou
SVN Extraire si vous avez installé la francisation de SVN). Dans la boı̂te de dialogue qui
apparaı̂t, entrez l’information suivante dans Url of Repository (URL du référentiel) :
svn://svn.code.sf.net/p/codeblocks/code/trunk
et laissez les autres paramètres comme ils sont.
Maintenant, soyez patient pendant que TortoiseSVN récupère les sources les plus récentes
du dépôt de Code::Blocks dans votre répertoire local. Oui ; toutes ces sources de Code::Blocks
viennent chez vous !
Pour plus d’informations sur le paramétrage de SVN, voir info dans SVN settings (Toute-
fois, ce greffon C::B n’existe plus dans les récentes versions de Code::Blocks). Si vous
n’aimez pas l’intégration dans l’explorateur ou cherchez une solution inter-plateforme
vous pouvez jeter un oeil sur RapidSVN.
6.2.3 wxWidgets
[,→Wxwidgets] est une librairie disponible sur plusieurs plateformes et qui fournit une
API supportant de nombreuses choses comme une Interface Graphique Utilisateur (GUI),
des sockets, fichiers, fonctionnalités de registres. En utilisant cette API, vous pouvez créer
des programmes indépendants des plateformes.
Code::Blocks est une application wxWidgets (aussi dénommées ci-dessous : wx), ce qui
signifie que pour exécuter Code::Blocks vous avez besoin des fonctionnalités wx. Cela peut
se faire de deux façons. Soit par une .dll soit par une librairie statique. Code::Blocks
utilise wx en tant que dll et cette dll peut aussi se télécharger depuis la section nightly
builds du forum.
Néanmoins, si nous voulons générer une application wx, nous devons inclure les headers
(ou en-têtes) des sources wx. Elles donnent au compilateur les informations sur les fonc-
tionnalités de wx. En plus de ces fichiers de headers, notre application a besoin d’être liée
aux librairies d’importation wx. Bien, voyons cela pas à pas.
Wx est fourni sous forme de fichiers sources dans un fichier zip, aussi, nous devons le
générer par nous-mêmes. Nous avons déjà le compilateur MinGW, donc nous avons tous
les outils nécessaires sous la main.
Dézippez maintenant les sources wx dans C:\Projets et ainsi nous aurons au final un
répertoire wx de base comme celui-ci : C:\Projets\wxWidgets-3.1.3. Ensuite, dézippez
les patchs (s’il y en a !) dans le même sous répertoire afin de remplacer les fichiers modifiés.
Notez que nous allons référencer le répertoire wx de base à partir de maintenant comme
<wxDir>
Maintenant, nous allons générer les wxWidgets. Voici comment faire :
Premièrement, assurez-vous que C:\MingGW\bin est dans votre variable path, car durant
la génération quelques programmes résidant dans le répertoire MinGW\bin seront appelés.
De plus, Make doit être en version 3.80 ou supérieure.
Code::Blocks 141
Il est temps maintenant de compiler les wxWidgets. Ouvrir une fenêtre de commande
DOS et se placer dans le répertoire des wxWidgets :
cd <wxDir>\build\msw
Nous sommes maintenant au bon endroit. Nous allons d’abord nettoyer les sources :
mingw32-make -f makefile.gcc SHARED=1 MONOLITHIC=1 BUILD=release UNICODE=1 clean
Maintenant que tout est propre, nous pouvons compiler les wxWidgets :
mingw32-make -f makefile.gcc SHARED=1 MONOLITHIC=1 BUILD=release UNICODE=1
Si vous utilisez le compilateur TDM-gcc 5.1.0, ou gcc 8.1.0, vous aurez à ajouter sur la
même ligne de commande :
USE_XRC=1
CXXFLAGS+="-fpermissive -fno-keep-inline-dllexport -std=gnu++11
-Wno-deprecated-declarations"
LDFLAGS="-Wl,--allow-multiple-definition"
Depuis la révision SVN 11701, Code::Blocks sous Windows est généré en activant/forçant
le support de DIRECT2D (pour une plus rapide et meilleure qualité graphique). La
génération de wxWidgets nécessite quelques ajustments à effectuer directement dans le(s)
fichier(s) setup.h. Normalement le seul fichier à modifier est dans le sous-répertoire lib,
celui créé lors de la première génération de wxWidgets, et utilisé par la suite. Pour une
génération par gcc, dll, c’est quelque chose comme : C:\wxWidgets-3.1.3\lib\gcc dll\mswu\wx.
Vous pouvez simplement modifier la ligne contenant (ligne 1593 dans wxWidgets 3.1.3):
#define wxUSE_GRAPHICS_DIRECT2D 0
par
#define wxUSE_GRAPHICS_DIRECT2D 1
Les autres setup.h peuvent être modifiés, mais ce n’est normalement pas requis.
en option :
USE_OPENGL=1
DEBUG_LEVEL=0
Note :
USE OPENGL=1 crée une dll supplémentaire, utilisée si votre pro-
gramme wxWidgets requiert une fenêtre OpenGL, notamment lorsque
vous utilisez wxGLCanvas
Code::Blocks 142
On peut aussi personnaliser le nom des dlls produites par :
VENDOR=cb
ou pour une génération en 64 bits :
VENDOR=cb_64
Note :
Si VENDOR n’est pas spécifié, cela revient à VENDOR=custom.
VENDOR=cb est utilisé par l’équipe de Code::Blocks. Aussi, pour
éviter toute confusion, il peut être prudent d’utiliser un autre identi-
fiant de ”vendor”.
La génération prend un certain temps.

Pour générer une version debug, suivez les mêmes étapes et options (le seul changement
est BUILD=debug) :
Nettoyer les précédentes compilations par
mingw32-make -f makefile.gcc SHARED=1 MONOLITHIC=1 BUILD=debug UNICODE=1 clean
Compiler par
mingw32-make -f makefile.gcc SHARED=1 MONOLITHIC=1 BUILD=debug UNICODE=1
Ajoutez éventuellement les mêmes options que ci-dessus.
Bien, regardons maintenant dans le répertoire (<wxDir>\lib\gcc dll). Les librairies
d’importation et les dll y sont visibles et il doit aussi y avoir un sous répertoire mswu\wx
à cet endroit, contenant setup.h.
Vous pouvez utiliser strip.exe (distribué avec MinGW) pour réduire la taille des dlls. par
ex:
strip ..\..\lib\gcc_dll\wxmsw313u_gcc_cb_64.dll
strip ..\..\lib\gcc_dll\wxmsw313u_gl_gcc_cb_64.dll
Bravo! Vous venez de générer les wxWidgets!

Faisons encore quelques tâches préliminaires complémentaires avant d’attaquer la compi-
lation de Code::Blocks.
6.2.4 Zip
Durant la génération de Code::Blocks, plusieurs ressources seront compressées dans des
fichiers zip. Aussi, le processus de génération doit pouvoir accéder à un zip.exe. Nous
Code::Blocks 143
devons télécharger ce zip.exe (s’il n’est pas déjà dans votre distribution MinGW) et le
mettre quelque part dans notre path. MingW\bin est un bon endroit pour cela.
Vous pouvez depuis ce site (http://www.info-zip.org/pub/infozip/Zip.html) télécharger
zip.exe gratuitement, ou depuis là (ftp://ftp.info-zip.org/pub/infozip/win32/) qui
est un lien direct vers un répertoire contenant les plus récentes versions.
Une fois téléchargé, extraire simplement zip.exe vers l’endroit approprié.
6.2.5 Espace de Travail - Workspace

Ceci nous amène à la dernière tâche préliminaire. Le code de Code::Blocks peut être divisé
en 2 parties : le coeur avec les plug-ins (ou greffons) internes, et les plug-ins contributifs.
Il est toujours nécessaire de générer le coeur/parties internes avant de générer les parties
contributives.
Pour générer les parties internes, vous pouvez utiliser le fichier projet de Code::Blocks
que vous trouverez dans : <cbDir>\src\CodeBlocks.cbp. Notre répertoire principal de
Code::Blocks est, de fait, maintenant repéré par <cbDir>. Un Espace de travail (ou
workspace) est quelque chose qui regroupe plusieurs projets ensemble. Pour générer les
plug-ins contributifs, on utilisera <cbDir>\src\ContribPlugins.workspace.
Mais on peut aussi créer un espace de travail contenant l’intégralité. On mettra cet espace
de travail dans le répertoire principal <cbDir>. Pour cela, utilisez un éditeur de texte
basique et créez un fichier nommé ”CbProjects.workspace”. Un tel fichier existe déjà dans
les versions récentes de C::B. Vous pouvez lui donner le contenu suivant :
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>

<CodeBlocks_workspace_file>
<Workspace title="CodeBlocks Workspace wx3.1.x">
<Project filename="CodeBlocks_wx31_64.cbp" active="1" />
<Project filename="tools/Addr2LineUI/Addr2LineUI_wx31.cbp" />
<Project filename="tools/cb_share_config/cb_share_config_wx31.cbp" />
<Project filename="tools/CBLauncher/CbLauncher_wx31.cbp" />
<Project filename="tools/cbp2make/cbp2make_wx31.cbp" />
<Project filename="plugins/codecompletion/cctest_wx31.cbp" />
<Project filename="plugins/contrib/wxContribItems/wxContribItems_wx31.cbp" />
<Project filename="plugins/contrib/wxSmith/wxSmith_wx31.cbp" />
<Project filename="plugins/contrib/wxSmithContribItems/wxSmithContribItems_wx31.cb
<Depends filename="plugins/contrib/wxContribItems/wxContribItems_wx31.cbp" />
<Depends filename="plugins/contrib/wxSmith/wxSmith_wx31.cbp" />
</Project>
<Project filename="plugins/contrib/wxSmithAui/wxSmithAui_wx31.cbp">
<Depends filename="plugins/contrib/wxSmith/wxSmith_wx31.cbp" />
</Project>
<Project filename="plugins/contrib/AutoVersioning/AutoVersioning_wx31.cbp" />
<Project filename="plugins/contrib/BrowseTracker/BrowseTracker_wx31.cbp" />
<Project filename="plugins/contrib/byogames/byogames_wx31.cbp" />
<Project filename="plugins/contrib/cb_koders/cb_koders_wx31.cbp" />
Code::Blocks 144
<Project filename="plugins/contrib/Cccc/Cccc_wx31.cbp" />

<Project filename="plugins/contrib/codesnippets/codesnippets_wx31.cbp" />
<Project filename="plugins/contrib/codestat/codestat_wx31.cbp" />
<Project filename="plugins/contrib/copystrings/copystrings_wx31.cbp" />
<Project filename="plugins/contrib/CppCheck/CppCheck_wx31.cbp" />
<Project filename="plugins/contrib/Cscope/Cscope_wx31.cbp" />
<Project filename="plugins/contrib/devpak_plugin/DevPakPlugin_wx31.cbp" />
<Project filename="plugins/contrib/DoxyBlocks/DoxyBlocks_wx31.cbp" />
<Project filename="plugins/contrib/dragscroll/DragScroll_wx31.cbp" />
<Project filename="plugins/contrib/EditorConfig/EditorConfig_wx31.cbp" />
<Project filename="plugins/contrib/EditorTweaks/EditorTweaks_wx31.cbp" />
<Project filename="plugins/contrib/envvars/envvars_wx31.cbp" />
<Project filename="plugins/contrib/FileManager/FileManager_wx31.cbp" />
<Project filename="plugins/contrib/FortranProject/FortranProject_cbsvn_wx31.cbp" /
<Project filename="plugins/contrib/headerfixup/headerfixup_wx31.cbp" />
<Project filename="plugins/contrib/help_plugin/help-plugin_wx31.cbp" />
<Project filename="plugins/contrib/HexEditor/HexEditor_wx31.cbp" />
<Project filename="plugins/contrib/IncrementalSearch/IncrementalSearch_wx31.cbp" /
<Project filename="plugins/contrib/keybinder/keybinder_wx31.cbp" />
<Project filename="plugins/contrib/lib_finder/lib_finder_wx31.cbp">
</Project>
<Project filename="plugins/contrib/MouseSap/MouseSap_wx31.cbp" />
<Project filename="plugins/contrib/NassiShneiderman/NassiShneiderman_wx31.cbp" />
<Project filename="plugins/contrib/profiler/cbprofiler_wx31.cbp" />
<Project filename="plugins/contrib/ProjectOptionsManipulator/ProjectOptionsManipul
<Project filename="plugins/contrib/regex_testbed/RegExTestbed_wx31.cbp" />
<Project filename="plugins/contrib/ReopenEditor/ReopenEditor_wx31.cbp" />
<Project filename="plugins/contrib/rndgen/rndgen_wx31.cbp" />
<Project filename="plugins/contrib/SmartIndent/SmartIndent_wx31.cbp" />
<Project filename="plugins/contrib/source_exporter/Exporter_wx31.cbp" />
<Project filename="plugins/contrib/SpellChecker/SpellChecker_wx31.cbp" />
<Project filename="plugins/contrib/symtab/symtab_wx31.cbp" />
<Project filename="plugins/contrib/ThreadSearch/ThreadSearch_wx31.cbp">
</Project>
<Project filename="plugins/contrib/ToolsPlus/ToolsPlus_wx31.cbp" />
</Workspace>
</CodeBlocks_workspace_file>
Note :
Il existe plusieurs variantes de ce fichier, dépendant de l’OS, de la
version wxWidgets, d’une génération en 32 ou 64 bits.
Nous utiliserons cet espace de travail pour générer complètement Code::Blocks.
Code::Blocks 145
6.2.6 Générer Codeblocks

Cette section descrit le processus final de la génération de Code::Blocks.
6.2.6.1 Windows
Nous sommes maintenant arrivés à l’étape finale ; notre but ultime. Lancez l’exécutable
Code::Blocks depuis votre téléchargement de ”nightly”. Ouvrir le menu Fichier, dans le
navigateur cherchez l’espace de travail adéquat et lances-le. Soyez patients pendant que
Code::Blocks analyse l’ensemble, puis on vous demandera de renseigner 3 ou 4 variables
globales. Celles-ci indiqueront à Code::Blocks où il trouvera les wxWidgets (pour mémoire
: les fichiers d’en-têtes et les librairies d’importation) et où il peut trouver les sources de
... Code::Blocks. Ceci est nécessaire pour les plug-ins contributifs (ainsi que pour les
plug-ins de l’utilisateur), qui doivent savoir où trouver le sdk (Les fichiers d’en-têtes de
Code::Blocks). Dans notre cas, cela peut donner :
wx <wxDir> répertoire de base des wxWidgets: le nom de la variable peut être wx31,
wx31 64,...
cb <cbDir>/src répertoire contenant les sources de Code::Blocks.
cb release type : -O (Pour obtenir une version release, cas habituel. Les développeurs
peuvent entrer -g pour débuguer C::B)
boost : répertoire de base où boost est installé (par ex : C:\boost). · Utilisé par le plugin
NassiShneiderman Remplissez avec la même valeur les sous-sections include et lib.
Aller maintenant dans le Menu Projet et choisissez (re)générer l’espace de travail, et allez
faire un tour. Regardez comment Code::Blocks est en train de générer Code::Blocks.
Après la création de Code::Blocks, les fichiers générés avec les informations de débogage
se trouvent dans le sous-répertoire devel. En appelant, ou lançant depuis une con-
sole, le fichier batch update.bat depuis le répertoire source <cbDir>/src (ou plus
spécifiquement la version adaptée à votre génération spécifique, comme par exemple
update31 64.bat), les fichiers sont copiés dans le sous-répertoire output (ou la version
adaptée). De plus, toutes les informations de débogage sont retirées. Cette étape est très
importante - ne jamais l’oublier.
Vous pouvez maintenant copier la dll wx à la fois dans ce répertoire output et, en option,
dans devel.
Vous pouvez alors fermer Code::Blocks. Rappelez-vous, nous utilisions la version nightly
téléchargée ?
Il est temps de tester la nouvelle version. Dans le répertoire output, lancez CodeBlocks.exe.
Si tout s’est bien passé, vous avez généré votre propre version de Code::Blocks faite maison.
6.2.6.2 Linux
(Note : Cette section devrait être revue et complétée. Elle ne semble pas
complètement à jour)
linux Lancer update revision.sh
Code::Blocks 146
Avec cette fonction la révision SVN de la génération Nightly est mise à jour dans les
sources. On peut trouver ce fichier dans le répertoire principal des sources de Code::Blocks.
Quand on génère sous Linux, les étapes suivantes sont nécessaires. Dans cet exemple nous
supposons que vous êtes dans le répertoire source de Code::Blocks. Sous Linux, la variable
d’environnement PKG_CONFIG_PATH doit être configurée. Le répertoire <prefix> doit
contenir le fichier codeblocks.pc.
PKG_CONFIG_PATH=$PKG_CONFIG_PATH:<prefix>
sh update_revsion.sh
./bootstrap
./configure --with-contrib=[all | noms des plugins separes par des virgules]
--prefix=<install-dir>
make
make install (en tant que root)
Vous pouvez aussi générer sous Linux comme sous Windows, avec un fichier workspace.
Toutefois, pkg config et wx-config doivent être correctement configurés.
6.2.7 Générer seulement les plugins

Cette section concerne la génération des plugins seulement.
6.2.7.1 Windows
Configurer les variables globales via ’Paramètres’ →’Variables Globales’ .

Variable cb
Pour la variable cb, entrer dans base le répertoire source de Code::Blocks.
<cbDir>/codeblocks/src
Variable wx
Pour la variable wx, entrer dans base le répertoire source de wx : par ex.
C:\wxWidgets-2.8.12
ou pour générer avec une version plus récente, wx31 (ou wx31 64)
C:\wxWidgets-3.1.4
Dans le projet Code::Blocks, la variable projet WX_SUFFIX est configurée à u. Cela

signifie que pendant la génération de Code::Blocks l’édition de liens se fera avec la librairie
*u gcc custom.dll (par défaut). Les générations officielles des nightlies de Code::Blocks
seront liées avec gcc cb.dll. Pour ce faire, il faut faire comme suit.
Code::Blocks 147
gcc_<VENDOR>.dll
La variable <VENDOR> est donnée dans le fichier de configuration compiler.gcc ou

via la ligne de commande de l’instruction make, comme montré précédemment. Pour
s’assurer qu’une distinction soit possible entre une génération officielle de Code::Blocks et
celles effectuée par vous-mêmes, la configuration par défaut VENDOR=custom ne devrait
pas être changée.
Après, créez l’espace de travail ContribPlugins.cbp via ’Projet’ →’Générer l’espace de
travail’ . Puis exécutez une fois de plus update.bat.
6.2.7.2 Linux
Configurez la variable wx à l’aide des variables globales.

base /usr
include /usr/include/wx-2.8 (ou la version installée sur votre machine)
lib /usr/lib
Code::Blocks 148
URL catalog
[,→7Z] 7z zip homepage.
http://www.7-zip.org
[,→ZIP] Info-zip Ftp page.
ftp://ftp.info-zip.org/pub/infozip/win32/
[,→SourceForgeCB] Codeblocks at Sourceforge.
https://sourceforge.net/p/codeblocks/code/log/
[,→SourceForgeCBSrc] Trunk SVN C::B Source on Sourceforge.
https://sourceforge.net/p/codeblocks/code/HEAD/tree/trunk/
[,→FORUM] Codeblocks forum.
http://forums.codeblocks.org/
[,→WIKI] Codeblocks wiki.
http://wiki.codeblocks.org/index.php/Main_Page
[,→CODEBLOCKS] Codeblocks homepage.
http://www.codeblocks.org/
[,→GCC] GCC home page.
http://gcc.gnu.org/
[,→MinGW] MinGW original page.
http://www.mingw.org/
[,→MinGW64] MinGW64 files page.
https://sourceforge.net/projects/mingw-w64/files/
[,→MinGW64-Ray-Linn] MinGW64 Ray Linn Personal page.
https://sourceforge.net/projects/mingw-w64/files/Multilib%20Toolchains%
28Targetting%20Win32%20and%20Win64%29/ray_linn/gcc-9.x-with-ada/
[,→MinGW64-Equation] MinGW64 Equation files page.
http://www.equation.com/servlet/equation.cmd?fa=fortran
[,→MinGW64-LHMouse] MinGW64 LHMouse files page.
https://gcc-mcf.lhmouse.com/
[,→MinGW64-WinLibs] MinGW64 WinLibs page.
http://winlibs.com/
[,→MSys2] Msys2 home page.
http://www.msys2.org/
[,→MSys2-MinGW64-Toolchain] Msys2 Toolchain for MinGW64.
https://packages.msys2.org/group/mingw-w64-x86_64-toolchain
[,→UnxUtils] Unix Like Utilities files page.
https://sourceforge.net/projects/unxutils/
[,→GnuWin32] An other Unix Like Utilities files page.
https://sourceforge.net/projects/gnuwin32/
Code::Blocks V2.0.1 beta URL catalog
[,→HIGHTEC] HighTec homepage.

http://www.hightec-rt.com/
[,→TortoiseSVN] TortoiseSVN homepage.

http://tortoisesvn.net/
[,→Subversion] Subversion Apache homepage.

http://subversion.apache.org/
[,→Wxwidgets] WxWidgets homepage.

http://www.wxwidgets.org/
[,→Wxcode] WxCode homepage.

http://wxcode.sourceforge.net/
[,→Scripts] Scripting commands.

http://wiki.codeblocks.org/index.php?title=Scripting_commands
[,→CBDoc] C::B documentation on the wiki.

http://wiki.codeblocks.org/index.php/Category:Code::Blocks_Documentation
[,→UserDoc] C::B User documentation on the wiki.

http://wiki.codeblocks.org/index.php/Category:User_Documentation
[,→NassiShneiderman] NassiShneiderman WiKi page.

https://www.wikipedia.org/wiki/Nassi-Shneiderman_diagram
[,→Launchpad Old] Old Translation page on Launchpad.

https://launchpad.net/codeblocks
[,→Launchpad New] New Translation page on Launchpad.

https://launchpad.net/codeblocks-gd
[,→Translation] Translation topic on CB Forum.

http://forums.codeblocks.org/index.php/topic,1022.0.html
Code::Blocks 150

Manual Codeblocks FR

Transféré par

Droits d'auteur :

Formats disponibles

Manual Codeblocks FR

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Manual Codeblocks FR

Transféré par

Droits d'auteur :

Formats disponibles

Code::Blocks

Version 2.0.1 beta

Merci à l’équipe Code::Blocks:

2.18.7 Panneau de Gestion . . . . . . . . . . . . . . . . . . . . . . . . . . 79

4 Travailler avec Code::Blocks 94

4.2.2 Changer la composition du fichier . . . . . . . . . . . . . . . . . . . 100

5 Installation et Configuration de CodeBlocks avec MinGW 130

6 Générer CodeBlocks à partir des Sources 138

URL catalog 149

L’illustration ci-dessous montre l’apparence de la fenêtre de l’interface utilisateur de

Figure 1.1: Environnement de développement Intégré (IDE) de Code::Blocks

1.1 Vue du projet

1.2 Notes pour les Projets

1.3 Modèles de Projet

1.4 Créer des Projets à partir de Cibles de Génération

Figure 1.2: Cibles de Génération

1.5 Cibles Virtuelles

1.6 Étapes Pré- et Post Génération

1.7 Ajouter des Scripts à des Cibles de Génération

1.8 Espace de travail et Dépendances de Projet

1.9 Inclure des Fichiers en Assembleur

1.10 Éditeur et Outils

1.10.1 Code par Défaut

Figure 1.3: Définition des abréviations

1.10.4 Fichiers de Configuration

1.10.5 Navigation et Recherche

Figure 1.4: Recherche de fichiers

Dans Code::Blocks vous pouvez facilement naviguer entre les En-têtes/Sources en :

Figure 1.5: Ouverture d’un fichier d’en-têtes

Figure 1.6: Recherche de fonctions

1.10.6 Vue des Symboles

Les catégories suivantes existent pour les symboles :

Figure 1.7: Vue des symboles

Figure 1.8: Activation de l’analyse en temps réel

1.10.7 Inclure des Fichiers d’Aide Externes

Figure 1.9: Configuration des fichiers d’aide

de l’ouvrir avec le visualiseur de fichiers HTML intégré, en cochant l’option corre-

Figure 1.10: Visualiseur HTML intégré

1.10.8 Inclure des outils externes

1.11 Astuces pour travailler avec Code::Blocks

1.11.1 Recherche de Modifications

Figure 1.11: Recherche de modifications

1.11.2 Échange de données avec d’autres applications

Les commandes suivantes sont actuellement disponibles :

Raise Donne le ”focus” à l’instance de Code::Blocks. Aucun paramètre ne

1.11.3 Configurer les variables d’environnement

Figure 1.12: Variables d’environnement

1.11.4 Basculer entre diverses dispositions

1.11.5 Basculer entre projets

1.11.6 Configurations étendue des compilateurs

Figure 1.13: Configurer des informations détaillées

Assurez-vous que le compilateur soit correctement sélectionné. L’option ’Ligne de com-

1.11.7 Zoomer dans l’éditeur

1.11.8 Mode de Repliement

1.11.9 Sélection de modes dans l’éditeur

1.11.10 Repliement de code

Code::Blocks fournit aussi la fonctionnalité de repliement pour les directives du pré-

1.11.11 Auto complétion

1.11.12 Recherche de fichiers cassés

Générateur de journal des changements.