🔝 Retour au Sommaire
Vous avez créé votre projet, ajouté des composants, écrit du code... Il est maintenant temps de transformer tout cela en une véritable application exécutable ! C'est là qu'intervient le processus de compilation.
La compilation peut sembler mystérieuse au début, mais c'est en réalité un processus logique et bien défini. Dans cette section, nous allons démystifier la compilation, comprendre ce qui se passe réellement quand vous appuyez sur F9, et apprendre à gérer les erreurs qui peuvent survenir.
Quand vous écrivez du code en Object Pascal, vous créez ce qu'on appelle du "code source" : un texte que vous pouvez lire et comprendre (plus ou moins facilement). Mais votre ordinateur ne peut pas exécuter directement ce code source. Il a besoin d'instructions en langage machine, un langage binaire que seul le processeur comprend.
La compilation est le processus qui transforme votre code source lisible par l'humain en code machine exécutable par l'ordinateur. C'est comme traduire un livre du français vers une langue que votre ordinateur comprend.
Le compilateur Delphi est un programme très sophistiqué qui :
- Lit votre code source : il parcourt tous vos fichiers .pas
- Vérifie la syntaxe : il s'assure que vous avez respecté les règles du langage Object Pascal
- Analyse le sens : il vérifie que votre code a du sens (les types sont cohérents, les variables sont déclarées, etc.)
- Optimise : il réorganise et améliore votre code pour qu'il s'exécute plus rapidement
- Génère le code machine : il traduit votre code en instructions processeur
- Lie les bibliothèques : il assemble votre code avec les bibliothèques nécessaires (VCL, RTL, etc.)
- Crée l'exécutable : il génère le fichier .exe final
Tout cela se passe en quelques secondes, parfois moins !
Certains langages (comme Python ou JavaScript) sont "interprétés" : le code est traduit ligne par ligne pendant l'exécution. Delphi, lui, est "compilé" : tout est traduit avant l'exécution.
L'avantage de la compilation :
- Vitesse d'exécution : votre programme tourne beaucoup plus vite
- Détection d'erreurs : beaucoup d'erreurs sont détectées avant même de lancer le programme
- Distribution : vous donnez un fichier .exe, pas le code source
L'inconvénient :
- Temps de compilation : vous devez attendre la compilation avant de tester
Mais avec Delphi, la compilation est généralement très rapide.
La façon la plus courante de compiler et exécuter votre application est d'appuyer sur F9 (ou cliquer sur le bouton vert "Exécuter" dans la barre d'outils).
Quand vous faites cela, Delphi :
- Sauvegarde tous les fichiers modifiés
- Compile votre projet
- Si la compilation réussit, lance automatiquement votre application
Si vous avez déjà lancé votre application et que vous appuyez à nouveau sur F9, Delphi détecte que l'application tourne déjà et vous propose de la terminer avant de recompiler.
Parfois, vous voulez juste vérifier que votre code compile correctement, sans lancer l'application. Utilisez Ctrl + F9 (ou menu Project > Compile [nom du projet] / Projet > Compiler).
Cela compile votre projet et vous indique s'il y a des erreurs, mais ne lance pas l'exécutable.
C'est utile pour :
- Vérifier rapidement votre code
- Compiler avant de fermer Delphi
- Compiler une DLL ou une bibliothèque qui ne peut pas se lancer seule
Normalement, Delphi est intelligent : il ne recompile que les fichiers qui ont changé depuis la dernière compilation. C'est ce qu'on appelle la "compilation incrémentale", et c'est ce qui rend Delphi rapide.
Mais parfois, vous voulez forcer une recompilation complète de tous les fichiers, depuis zéro. Utilisez Shift + F9 (ou menu Project > Build / Projet > Construire).
Utilisez cette option quand :
- Vous soupçonnez un problème de compilation incrémentale
- Vous avez modifié des options du projet
- Vous passez d'une configuration à une autre (Debug vers Release)
- Quelque chose semble "cassé" sans raison apparente
Pour supprimer tous les fichiers générés par la compilation (fichiers .dcu, .exe, etc.) et repartir de zéro : Project > Clean (Projet > Nettoyer).
Cela peut résoudre certains problèmes mystérieux de compilation, notamment quand des fichiers .dcu obsolètes traînent.
Le compilateur lit votre code et vérifie que vous respectez les règles de grammaire du langage Object Pascal :
- Les instructions se terminent-elles par un point-virgule ?
- Les blocs begin/end sont-ils équilibrés ?
- Les mots-clés sont-ils correctement utilisés ?
Si vous avez fait une faute de frappe ou oublié un point-virgule, c'est à ce stade que l'erreur sera détectée.
Le compilateur vérifie que votre code a du sens :
- Les variables sont-elles déclarées avant d'être utilisées ?
- Les types sont-ils compatibles (vous ne pouvez pas assigner une chaîne à un entier) ?
- Les fonctions sont-elles appelées avec le bon nombre de paramètres ?
- Les propriétés que vous utilisez existent-elles ?
C'est à ce stade que les erreurs de logique de typage sont détectées.
Si tout est correct, le compilateur génère des fichiers intermédiaires appelés "unités compilées" (fichiers .dcu pour Delphi Compiled Unit). Ces fichiers contiennent le code machine correspondant à vos unités .pas.
Les .dcu sont stockés dans le dossier de sortie (généralement Win64\Debug pour Delphi 13, ou Win32\Debug si vous ciblez le 32 bits).
L'éditeur de liens (linker) prend tous vos fichiers .dcu et les assemble avec les bibliothèques nécessaires (VCL, RTL, bibliothèques système) pour créer le fichier .exe final.
C'est aussi à ce stade que sont incorporées les ressources (icône de l'application, fichiers .dfm, etc.).
Le fichier .exe est créé dans le dossier de sortie. Il est prêt à être exécuté !
Pendant la compilation, vous verrez en bas de l'IDE la fenêtre Messages qui affiche la progression :
Compilation démarrée
Compilation de MonProjet.dpr
Compilation de FormPrincipale.pas
...
Compilation réussie
Temps écoulé : 00:00:01.2
Cette fenêtre est importante : c'est là que s'afficheront les erreurs et avertissements.
Les erreurs, affichées en rouge, sont des problèmes graves qui empêchent la compilation. Tant qu'il y a des erreurs, vous ne pouvez pas créer l'exécutable.
Exemples d'erreurs courantes :
"Undeclared identifier 'X'" : vous utilisez une variable ou une fonction 'X' qui n'a pas été déclarée. Vérifiez l'orthographe, et assurez-vous que la bonne unité est dans votre clause uses.
"Incompatible types" : vous essayez d'assigner une valeur d'un type à une variable d'un autre type incompatible. Par exemple, assigner une chaîne à un entier.
"';' expected" : vous avez oublié un point-virgule quelque part.
"'BEGIN' expected" : la structure de votre code est incorrecte, probablement un begin/end manquant ou mal placé.
"Identifier redeclared" : vous avez déclaré deux fois la même variable ou fonction.
Les avertissements, affichés en jaune, sont des problèmes potentiels qui ne bloquent pas la compilation, mais qui méritent votre attention.
Exemples d'avertissements courants :
"Variable 'X' might not have been initialized" : vous utilisez peut-être une variable avant de lui avoir donné une valeur. C'est dangereux car elle contiendra une valeur aléatoire.
"Comparison always evaluates to True/False" : vous faites une comparaison dont le résultat est toujours le même. C'est probablement une erreur de logique.
"Return value might be undefined" : une fonction ne retourne pas toujours une valeur dans tous les cas possibles.
"Local variable 'X' is assigned but never used" : vous avez modifié une variable que vous n'utilisez jamais ensuite. Ce n'est pas critique, mais c'est du code mort.
Ne négligez pas les avertissements ! Même s'ils ne bloquent pas la compilation, ils signalent souvent de vrais bugs.
Les indications, affichées en bleu, sont des suggestions mineures pour améliorer votre code. Elles n'indiquent généralement pas de problème réel.
Exemples :
"Private symbol 'X' declared but never used" : une méthode ou variable privée que vous n'utilisez pas.
"Parameter 'X' not used" : un paramètre de fonction que vous ne lisez jamais.
Les indications peuvent généralement être ignorées, surtout au début. Mais dans du code professionnel, on essaie de les éliminer pour avoir un code propre.
Double-cliquez sur un message d'erreur ou d'avertissement pour naviguer directement vers la ligne de code concernée. C'est très pratique pour corriger rapidement les problèmes.
Vous pouvez aussi filtrer les messages par type (erreurs, avertissements, indications) en utilisant les boutons en haut de la fenêtre Messages.
Quand vous avez plusieurs erreurs, ne paniquez pas ! Suivez cette stratégie :
-
Lisez le premier message d'erreur : souvent, une seule erreur en génère plusieurs. Corrigez d'abord celle tout en haut de la liste.
-
Localisez le problème : double-cliquez sur le message pour aller à la ligne concernée.
-
Comprenez l'erreur : lisez le message d'erreur attentivement. Que dit-il exactement ? Parfois, le message est clair ; parfois, il faut réfléchir un peu.
-
Corrigez : faites la correction nécessaire.
-
Recompilez : appuyez sur F9 ou Ctrl + F9 pour voir si l'erreur est résolue.
-
Répétez : s'il reste des erreurs, recommencez avec la première de la liste.
Une seule erreur peut en provoquer plusieurs autres. Par exemple, si vous oubliez de déclarer une variable, toutes les lignes qui l'utilisent généreront une erreur "Undeclared identifier".
C'est pourquoi il faut toujours corriger les erreurs dans l'ordre, de haut en bas. Souvent, corriger la première erreur fait disparaître plusieurs autres.
Si vous ne comprenez pas un message d'erreur, sélectionnez-le et appuyez sur F1 pour ouvrir l'aide de Delphi. L'aide fournit souvent des explications détaillées et des exemples.
Vous pouvez aussi chercher l'erreur sur internet. La communauté Delphi est très active, et il y a de fortes chances que quelqu'un ait déjà rencontré et résolu le même problème.
"Unit X not found"
- Cause : l'unité X n'est pas dans le chemin de recherche
- Solution : ajoutez l'unité au projet ou configurez le chemin de recherche dans les options du projet
"Cannot assign to a read-only property"
- Cause : vous essayez de modifier une propriété en lecture seule
- Solution : certaines propriétés ne peuvent être définies qu'à la création ou via des méthodes spécifiques
"Access violation at address..." (à l'exécution)
- Cause : vous accédez à une zone mémoire invalide (pointeur nil, objet non créé, etc.)
- Solution : vérifiez que vos objets sont bien créés avant utilisation, et que vous n'accédez pas à des indices hors limites
"Abstract Error" (à l'exécution)
- Cause : vous appelez une méthode abstraite qui devrait être implémentée dans une classe dérivée
- Solution : implémentez la méthode dans votre classe ou utilisez une classe non abstraite
Delphi propose deux configurations principales de compilation :
C'est la configuration par défaut pendant le développement. Caractéristiques :
Optimisations minimales : le compilateur ne réorganise pas trop le code, pour qu'il soit plus facile à déboguer
Informations de débogage incluses : des données supplémentaires sont ajoutées pour permettre le débogage (points d'arrêt, inspection de variables, etc.)
Vérifications supplémentaires : contrôles des débordements, assertions, etc.
Fichier .exe plus gros : à cause des informations supplémentaires
Performance réduite : le code est moins optimisé
Utilisez cette configuration pendant tout le développement.
C'est la configuration pour la version finale de votre application. Caractéristiques :
Optimisations maximales : le compilateur réorganise le code pour maximiser la performance
Pas d'informations de débogage : l'exécutable est plus petit
Vérifications désactivées : pour gagner en vitesse
Fichier .exe plus petit : grâce aux optimisations
Performance maximale : le code tourne plus vite
Utilisez cette configuration uniquement pour créer la version finale à distribuer.
Pour changer de configuration :
- Dans la barre d'outils, trouvez le menu déroulant qui affiche "Debug" ou "Release"
- Cliquez dessus et sélectionnez la configuration souhaitée
Ou via le Project Manager (à droite) : développez Build Configurations, faites un clic droit sur Debug ou Release et choisissez Activate (Activer).
Delphi 13 permet de compiler pour différentes plateformes :
Win32 (Windows x86) : Windows 32 bits — compatible avec Windows 10 et 11 (Windows 7/8 ne sont plus officiellement pris en charge). Utile pour les anciennes applications héritées ou pour cibler des machines avec peu de mémoire.
Win64 (Windows x64) : Windows 64 bits — recommandé par défaut pour la plupart des applications modernes.
Win64 (Arm) : Windows on Arm via Arm64EC (nouveauté Delphi 13.1) — pour les machines Windows ARM modernes (Copilot+ PC avec Snapdragon X Elite/Plus, Surface Pro 11, Surface Laptop 7, etc.).
macOS (x64 et ARM Apple Silicon) : nécessite un Mac accessible via PAServer (voir chapitre 1.5).
iOS (Device et Simulator) : applications iPhone et iPad. Nécessite un Mac.
Android 64 bits : applications pour smartphones et tablettes Android. Google Play exige désormais le 64 bits ; le 32 bits Android est obsolète et n'est plus retenu pour les nouvelles publications.
Linux 64-bit : applications serveur ou desktop (avec FMXLinux pour la GUI).
Pour changer de plateforme :
- Dans l'Explorateur de projets, clic droit sur le projet → Target Platforms
- Choisissez Add Platform (Ajouter une plateforme)
- Sélectionnez la plateforme souhaitée
- Dans la barre d'outils, sélectionnez la plateforme active dans le menu déroulant
⚠️ Restrictions selon votre édition :
- Community Edition : Win32, Win64, macOS, iOS, Android (pas de Linux)
- Professional / Enterprise / Architect : toutes les plateformes
Voir le chapitre 1.3 pour les détails sur les éditions.
Pour débuter, concentrez-vous sur Win64 (la plateforme moderne par défaut). Les autres plateformes nécessitent des configurations supplémentaires (PAServer pour Mac/iOS, SDK Android, etc.).
Après une compilation, plusieurs fichiers et dossiers sont créés :
C'est le dossier principal de sortie. Il contient :
Debug ou Release (sous-dossier) : contient l'exécutable final et les fichiers nécessaires
À l'intérieur de Debug/Release, vous trouverez :
- MonProjet.exe : votre application exécutable
- Fichiers .dcu : les unités compilées (fichiers intermédiaires)
- Fichiers .res : les ressources compilées
- Fichiers .map : informations de débogage (si activées)
Ces fichiers sont générés pendant la compilation et peuvent être supprimés (via "Nettoyer le projet") :
Fichiers .dcu : unités compilées, générées à partir des .pas
Fichiers .~pas, .~dfm : fichiers de sauvegarde automatique de Delphi
__history (dossier) : historique des modifications de fichiers
__recovery (dossier) : fichiers de récupération en cas de crash
Ces fichiers ne sont pas nécessaires pour l'exécution de votre application. Seul le .exe l'est (et éventuellement des DLL si vous en utilisez).
Pour distribuer votre application, vous avez besoin au minimum du fichier .exe compilé en mode Release.
Attention : votre .exe peut avoir besoin de fichiers supplémentaires :
- DLL externes si vous en utilisez
- Fichiers de ressources (images, sons, etc.) si vous les chargez depuis le disque
- Fichiers de base de données si votre application en utilise
Nous verrons la distribution en détail dans un chapitre ultérieur.
Menu Project > Options (Projet > Options), puis section Building > Delphi Compiler (Compilation > Compilateur Delphi).
Vous y trouverez de nombreuses options regroupées en sous-sections :
- Compiling : optimisation, syntaxe, débordement
- Hints and Warnings : avertissements et indications
- Linking : éditeur de liens
- Directories and Conditionals : chemins et symboles conditionnels
Pour débuter, les valeurs par défaut sont généralement appropriées, mais voici quelques options importantes à connaître :
Syntaxe étendue : active des fonctionnalités modernes du langage. Recommandé : activé.
Chaînes longues : utilise les chaînes modernes (String) au lieu des anciennes ShortString. Recommandé : activé.
Informations de débogage : indispensable en mode Debug, désactivé en Release.
Assertions : active les assertions (vérifications de conditions dans le code). Utile pour détecter les bugs.
Vérification des débordements : vérifie que les calculs ne dépassent pas les limites des types. Ralentit un peu le code mais évite des bugs.
Vérification des E/S : vérifie les erreurs d'entrée/sortie fichier. Recommandé.
Optimisation : niveau d'optimisation du code (aucune, basique, complète).
Inline : permet au compilateur d'insérer le code de petites fonctions directement dans le code appelant, pour gagner en vitesse.
Élimination du code mort : supprime le code qui n'est jamais exécuté.
En mode Debug, désactivez les optimisations pour faciliter le débogage. En mode Release, activez-les toutes pour maximiser la performance.
Vous pouvez configurer quels avertissements et indications afficher. Par défaut, Delphi est bien configuré, mais vous pouvez :
- Transformer un avertissement en erreur (pour le forcer à être corrigé)
- Désactiver certaines indications qui vous gênent
- Activer des vérifications supplémentaires
Par défaut, Delphi ne recompile que ce qui a changé. Pour que cela fonctionne bien :
- Sauvegardez régulièrement vos fichiers
- Ne modifiez pas manuellement les fichiers .dcu
- Utilisez "Nettoyer" si vous soupçonnez un problème
Plus vos unités sont petites et bien séparées, plus la compilation incrémentale est efficace. Si vous modifiez une petite unité, seule celle-ci sera recompilée.
À l'inverse, si tout votre code est dans un seul gros fichier, tout sera recompilé à chaque modification.
Les bibliothèques que vous ne modifiez pas (VCL, composants tiers) sont déjà précompilées. C'est pourquoi elles ne rallongent pas le temps de compilation.
Évidemment, un ordinateur plus rapide compile plus vite ! Mais surtout :
- SSD : un disque SSD accélère grandement la compilation (la compilation lit beaucoup de petits fichiers)
- RAM : au moins 8 Go, idéalement 16 Go ou plus pour Delphi 13 (IDE 64 bits)
- Processeur : un processeur rapide reste utile, même si le compilateur Delphi Pascal est historiquement orienté single-thread. Certaines opérations (liaison, génération de ressources, compilation de plusieurs projets en parallèle dans un groupe) bénéficient de plusieurs cœurs.
Delphi propose des directives de compilation que vous pouvez insérer directement dans votre code pour contrôler localement le comportement du compilateur. Elles s'écrivent entre {$ ... } :
// Activer/désactiver des optimisations localement
{$O+} // Optimisations ON
{$O-} // Optimisations OFF
// Vérification des débordements
{$Q+} // Vérification ON (détecte les dépassements d'entiers)
{$Q-} // OFF
// Vérification des limites de tableaux
{$R+} // ON (utile en debug)
{$R-} // OFF (plus rapide en release)
// Compilation conditionnelle
{$IFDEF DEBUG}
OutputDebugString('Mode debug activé'); // visible dans Event Log de l'IDE
{$ENDIF}
{$IFDEF MSWINDOWS}
// Code spécifique à Windows (utilise l'API Win32/Win64)
{$ENDIF}
{$IFDEF ANDROID}
// Code spécifique à Android
{$ENDIF}
// Régions repliables dans l'éditeur
{$REGION 'Mes méthodes privées'}
// Plusieurs procédures...
{$ENDREGION}
// Inclusion de fichiers
{$INCLUDE MyDefines.inc}
// Directives liées aux ressources
{$R MaRessource.RES}
{$R *.dfm}Ces directives sont très puissantes pour adapter votre code aux différentes plateformes ou aux différentes configurations (debug/release). Nous y reviendrons en détail dans le chapitre 3.
Si Delphi refuse de compiler sans raison apparente :
- Fermez et relancez Delphi
- Nettoyez le projet
- Vérifiez que les fichiers ne sont pas en lecture seule
- Vérifiez les droits d'accès au dossier du projet
L'application est probablement encore en cours d'exécution. Fermez-la complètement, puis recompilez.
Ou un antivirus bloque la création du fichier. Ajoutez une exception pour votre dossier de projets.
- Désactivez temporairement l'antivirus pour le dossier du projet
- Vérifiez que votre disque n'est pas plein
- Fermez les autres applications gourmandes
- Utilisez un SSD plutôt qu'un disque dur
Après avoir mis à jour Delphi ou des composants :
- Nettoyez le projet
- Recompilez tout (Shift + F9)
- Si ça ne suffit pas, supprimez manuellement tous les .dcu
Ne laissez pas des heures de code s'accumuler sans compiler. Compilez régulièrement, même si votre code n'est pas terminé. Cela permet de détecter les erreurs tôt.
Ne laissez pas les avertissements s'accumuler. Corrigez-les au fur et à mesure. Un code sans avertissements est généralement un code de meilleure qualité.
Tout votre développement et vos tests doivent se faire en mode Debug. Ce n'est qu'à la toute fin, juste avant la distribution, que vous compilez en Release.
Delphi sauvegarde automatiquement, mais prenez l'habitude de sauvegarder manuellement (Ctrl + S) avant de compiler. C'est un réflexe de sécurité.
Un système comme Git vous permet de revenir en arrière si une compilation casse tout. Committez régulièrement votre code qui compile.
Si vous modifiez des options de compilation non standard, documentez pourquoi dans un fichier README ou dans les commentaires du projet. Votre "vous futur" (ou vos collègues) vous remerciera.
La compilation est le pont entre votre code et l'application finale. Comprendre ce processus vous permet de :
- Travailler plus efficacement en compilant au bon moment
- Corriger les erreurs plus rapidement en comprenant les messages
- Optimiser vos applications en choisissant les bonnes options
- Distribuer correctement en créant les bons exécutables
Voici les points essentiels à retenir :
- F9 compile et exécute : c'est votre raccourci principal
- Corrigez les erreurs de haut en bas : une erreur peut en masquer d'autres
- Ne négligez pas les avertissements : ils signalent souvent de vrais problèmes
- Debug pour développer, Release pour distribuer : utilisez la bonne configuration
- Compilez souvent : pour détecter les erreurs tôt
Avec la pratique, la compilation deviendra une seconde nature. Vous compilerez sans même y penser, et vous saurez instinctivement corriger les erreurs courantes.
Dans la prochaine section, nous verrons comment personnaliser l'IDE Delphi pour l'adapter à vos préférences et améliorer votre productivité !