UEStudio propose par défaut plus de 50 compilateurs et assembleurs. Il peut être cependant nécessaire d'ajouter un compilateur non encore supporté par UEStudio.
Ajout d'un nouveau compilateur
Les fichiers de configuration des compilateurs sont similaires aux fichiers INI et se composent de sections, clés et leurs valeurs. Chaque configuration ne permet de créer qu'une seule “cible” (application, bibliothèque, bibliothèque dynamique) : dans de nombreux cas les compilateurs nécessitent plusieurs configurations et c'est pourquoi chaque compilateur possède son propre répertoire avec ses fichiers de configuration.
En premier lieu il s'agit de créer un nouveau répertoire sous UES_PATHConfigs. Le meilleur nom pour ce répertoire est le nom du compilateur à ajouter. À des fins d'illustration uniquement, nous créerons une configuration pour le Compilateur Alpha.
Pour démarrer la création d'une nouvelle configuration, ouvrez un nouveau fichier dans UEStudio. Dans notre exemple nous utiliserons une Application Win32. Veuillez noter que lorsque le fichier de configuration est terminé, le répertoire et les noms de fichier ajoutés seront utilisés pour peupler la liste des compilateurs dans UEStudio :
Certaines sections sont obligatoires et d'autres sont facultatives et étendent les fonctionnalités du système de génération dans sa globalité. Le contenu du fichier de configuration sera utilisé pour remplir les informations affichées dans la configuration du compilateur dans UEStudio lorsque le bouton Modifier la configuration est actionné dans la boîte de dialogue Sélectionner le compilateur. La première et la plus importante des sections est nommée General. Par conséquent nous devons créer une nouvelle section - [General].
[General] Options de configuration
Comme mentionné précédemment, il s'agit de configurations orientées "cible". Ainsi, la première clé à créer est la clé TargetExt. Pour les applications Windows/DOS, la valeur de cette clé est généralement “.exe”. Pour les bibliothèques la valeur sera généralement “.lib”, pour les compilateurs GCC ".a", et pour les bibliothèques dynamiques “.dll”. N'importe quelle extension peut être utilisée ici et le compilateur générera une application dotée de cette extension.
Tous les fichiers "générés" (fichiers objet, etc.) sont stockés dans des dossiers autonomes afin de conserver un environnement de projet propre. Chaque configuration supporte deux modes : release et debug. Les deux clés peuvent être définies ici : ReleaseOut et DebugOut, mais vous devrez au minimum définir la valeur de la clé ReleaseOut. Si la clé DebugOut n'est pas définie, elle utilisera automatiquement la valeur de la clé ReleaseOut. Les valeurs par défaut sont Release et Debug, mais pouvez utiliser les valeurs que vous souhaitez.
Si le compilateur/lieur ne fonctionne qu'avec des "chemins complets" (n'accepte pas de chemins relatifs pour les fichiers), une nouvelle clé UseFullPaths devra être crée avec la valeur “1”. Si les paramètres sont créés pour un compilateur DOS qui n'accepte pas les noms de fichier longs, vous aurez également besoin de créer la clé UseDosNames à qui vous attribuerez également la valeur “1”.
Il arrive parfois qu'un projet contienne des fichiers compilables que les utilisateurs ne souhaitent pas compiler. (Par exemple s'ils ne sont pas encore terminés ou parce que des erreurs ne peuvent pas être corrigées à temps.) Ces fichiers peuvent être déplacés dans un dossier spécial et le système de génération de UEStudio ne les transmettra pas au compilateur/lieur. Vous pouvez définir n'importe quel nom pour le dossier à l'exception de “External Dependencies”. Ce nom est réservé pour le système de génération de UEStudio et est automatiquement créé/supprimé durant la génération. Il est alors conseillé de ne PAS utiliser ce dossier de projet pour stocker des fichiers utilisateur. Pour spécifier le nom de ce dossier spécial, créez une nouvelle clé nommée Excludes et définissez le nom de dossier de projet spécial, par exemple “Fichiers exclus”.
Certains compilateurs nécessitent que les fichiers objet se trouvent dans le même dossier que les fichiers source, car ils n'acceptent que des noms de fichier (le nom du fichier source) comme paramètres, donc sans le chemin. Lorsque le système de génération crée des chemins relatifs pour les fichiers transmis au compilateur, ces chemins commencent toujours par des noms de dossier. Lorsque le dossier de sortie est identique au dossier source, ces chemins commencent par “.”. Mais dans le cas de compilateurs qui n'acceptent que des noms de fichier, UEStudio ne peut pas transmettre les chemins. C'est pourquoi une nouvelle clé nommée RemoveDot doit être créée avec la valeur “1”.
Si le compilateur utilisé n'accepte que des chemins du type Unix (avec des slashs simples) à la place des chemins classiques DOS/WIN (antislashs), vous devrez créer une clé nommée ConvertBS et lui attribuer la valeur “1”. Le caractère “/” sera alors utilisé à la place de “” dans les chemins. La section General de notre exemple ressemble maintenant à ceci :
[General]
TargetExt = .EXE
DebugOut = Debug
ReleaseOut = Release
Excludes = Fichiers exclus
Options de configuration Options des sections de commande
Les sections de commande précisent à UEStudio comment générer une application ou compiler un fichier. Il existe également d'autres sections de commande, moins importantes. Ils permettent toutefois de configurer d'autres outils qui permettent de manipuler les fichiers projet/source/cible. La plus importante de ces sections se nomme [Build]. Elle doit faire partie intégrante de toutes les configurations.
Clé de base de cette section : Out. Cette clé indique à UEStudio ce qui doit être créé avec les commandes définies. Quelle que soit la configuration, vous devrez TOUJOURS attribuer la valeur “$T” à cette clé. Toutes les sections de commande acceptent des valeurs spéciales commençant par le symbole $. Ces valeurs sont décrites dans la section commentée, au début de chaque fichier de configuration. Les plus importantes : $T pour le fichier cible, $P pour le fichier projet, et $O pour le fichier de sortie. Chaque section de commande peut se référer à un de ces fichiers. Dans la section [Build] il s'agit de la valeur définie pour la clé Out, dans la section [Compile] c'est la valeur du fichier d'entrée - $I qui est utilisée.
La création du fichier de sortie (dans le fichier cible de la section [Build]) est dépendant de la création d'autres fichiers. Pour que le fichier de sortie puisse être créé, vous devez définir la clé Depends avec la valeur appropriée. Pour la section [Build], elle peut représenter une liste de fichiers objets - par exemple $FGO. Comme nous l'avons vu plus haut, chaque configuration peut “traiter” deux modes de génération - release et debug. Si vous souhaitez utiliser cette possibilité, deux clés spéciales doivent être créées : ReleaseFlag et DebugFlag. Ces clés peuvent aussi bien être définies pour la section [Build] que pour toutes les sections des compilateurs. La plupart des compilateurs prennent en charge ces deux modes. Dans le mode debug, ils ajouteront des informations importantes dans les objets et les exécutables pour permettre un débogage du code. Dans le mode release (utilisation en production), ces informations ne sont pas incluses. Les valeurs de ces clés sont "déployées" dans les commandes du compilateur, où la valeur spéciale $R (le paramètre release/debug pour le lieur) est utilisée.
Nous devons maintenant créer les clés de commande. Chaque section de commande doit au moins contenir une commande. Elles sont définies à l'aide des clés Cmd0, Cmd1, Cmd2, etc. Dans la plupart des cas, une seule commande suffit, mais vous pouvez en définir plusieurs si cela s'avère nécessaire. Notre section [Build] ressemble maintenant à ceci :
[Build]
Out = $T
Depends = $FGO
DebugFlag = /debug
Cmd0 = linker $R -out $O -input $FGO
Exemple : étant donné que le fichier cible sera "Application.EXE", DebugFlag reçoit la valeur "/debug", ReleaseFlag n'est pas défini et le projet ne contient qu'un seul fichier source "exemple.cpp". La commande Cmd0 utilisée lors de la génération ressemblera à ceci :
"compiler /debug -out Application.EXE -input exemple.obj”
dans le mode debug. Si nous avions utilisé le mode release, nous aurions la même commande, à l'exception du paramètre “/debug” qui disparaît.
Si le compilateur utilisé ne permet pas l'emploi de lignes de commande longues, mais qu'il accepte des “fichiers de réponse” (des fichiers contenant les options de la ligne de commande), UEStudio peut générer pour vous ces fichiers de réponse. Les fichiers de réponse peuvent être simplement créés en modifiant l'index après file@, ainsi les clés contenant les informations de création des fichiers de réponse seront nommés “file@0”, “file@1”, etc. La valeur de ces clés se compose des informations relatives au nom du fichier réponse à créer et ses paramètres (options du compilateur/lieur). Nous obtiendrons alors une valeur du type “[nomdefichier.ext] option1 option2”. Les groupes de fichier et autres variables peuvent également être spécifiés ici. Si les options à inclure dans le fichier de réponse doivent être présentées sur plusieurs lignes, utilisez le symbole "|" pour séparer les différentes options. Si les fichiers réponse et objet devaient se trouver sur une ligne différente (à l'écart des autres options de compilation), la section [Build] d'exemple se verrait ajouter les clés suivantes :
file@0 = [monfichier.reponse] -out $O | -input $FGO
Cmd0 = linker $R @monfichier.reponse
Maintenant que les sections [General] et [Build] sont définies, nous pouvons nous occuper des autres sections de compilation. Ces sections ne sont pas obligatoires, mais elles font généralement partie de la configuration des compilateurs. C'est pourquoi nous les décrirons également. Si nous prenons l'exemple d'une configuration pour un compilateur C, au moins une section nommée [.C] doit être créée. Plusieurs configurations peuvent être définies pour décrire le type de traitement pour chaque type de fichier source. Toutefois, si le compilateur utilisé traite différents fichiers source de la même manière (par ex. : .C, .Cpp, .Cxx), il n'est pas nécessaire d'insérer une nouvelle section pour chacune de ces extensions ([.C], [.Cpp], [.Cxx]). Il suffit de créer dans la section [General] les clés qui indiqueront à UEStudio les sections à utiliser. Par exemple, la ligne
.CPP = .C
pourra être insérée dans la section [General]0 ; ainsi UEStudio utilisera la section [.C] pour tous les fichiers “.C” et “.CPP”. La section du compilateur (dans notre exemple [.C]) contiendra toutes les clés décrites dans la section [Build], et seules les valeurs différeront. Dans ces sections, la clé spéciale $I pourra être utilisée pour le chemin complet du fichier source (par exemple “application.cpp”). Toutes les clés spéciales contenant des chemins pourront également être utilisées pour extraire les noms, les chemins ou les extensions. Vous pourrez par exemple utiliser $Ip pour le chemin, $In pour le nom, et $Ie pour l'extension du fichier source (la même méthodologie peut être appliquée pour $P, $T et $O.) Ainsi, notre section d'exemple du compilateur sera constituée des clés et valeurs suivantes :
[.C]
Out = $In.obj
Depends = $I
DebugFlag = /debug
Cmd0 = compiler $R -out $O -input $I
Cette section peut également contenir des clés relatives à l'inclusion de fichiers, de façon à ce que UEStudio puisse les utiliser ainsi que leurs symboles lors de l'analyse des fichiers source se référant aux fichiers inclus. La première clé, IncFiles, indiquera à UEStudio que ce fichier peut contenir des fichiers d'inclusion. Par défaut, les fichiers d'inclusion sont recherchés uniquement dans le dossier courant. La clé IncDirs peut ensuite être définie pour spécifier une liste de dossiers dans lesquels les fichiers d'inclusion doivent être recherchés. Vous devez utiliser ici le même format que celui utilisé pour la variable d'environnement PATH (dossiers séparés par le symbole ';') et la valeur “$(INCLUDE)” peut être définie ici. Les valeurs de la forme "$(quelquechose)" sont des variables et clés de référence définies dans la section [Variables] (voir plus haut). Vous devez ensuite spécifier les mots clé utilisés pour l'inclusion des fichiers. Pour les langages C/C++, il s'agira du mot clé #include, pour NASM ce sera %include, et pour l'assembleur de Microsoft simplement include. Si ces mots clé sont sensibles à la casse, vous devez ajouter la clé CaseSensitive et lui attribuer la valeur “1”.
La plupart des fichiers source autorisent l'utilisation de commentaires - lignes ou bloc de commentaire. Les commentaires ne sont pas compilés, et les fichiers d'inclusion définis dans les commentaires sont par conséquent ignorés. Si le compilateur autorise l'emploi de commentaires, vous devez également ajouter la clé Comments. Elle utilise la syntaxe suivante :
SymboleInitiantLeCommentaire[point]SymboleTerminantLeCommentaire[point]
La fin de ligne (pour les commentaires sur une ligne) doit être spécifiée à l'aide de la chaîne de caractères “eol”. Chaque bloc de commentaires possède un symbole de début et de fin. Ces symboles doivent toujours être définis par paire. Si nous reprenons notre section d'exemple [.C], nous devrions intégrer les clés suivantes :
IncFiles = 1
CaseSensitive = 0
IncDirs = .;$(INCLUDE);
IncKeyWords = include;
Comments = //.eol./*.*/.
Options de configuration [FileGroups] et [GroupFormats]
La valeur $FGO (une liste de groupes de fichiers) a été utilisée dans la section [Build]. Vous pouvez définir autant de groupes de fichiers que vous le souhaitez - y compris tous les fichiers du projet et les fichiers générés durant la génération (par exemple pour les fichiers objet). Pour définir des groupes de fichier, créez une nouvelle section nommée [FileGroups] et incluez la clé FGO. Les extensions de fichiers à utiliser pour créer les groupes de fichiers peuvent être définis sous la forme d'une valeur, de noms de dossier du projet ou de groupes spécifiques. Dans notre exemple, la valeur pourrait être “.obj”. Généralement, les fichiers objet sont transmis au lieur sous la forme d'une simple liste de fichiers. Mais parfois un format spécifique est nécessaire pour transférer les fichiers objet (ou source) au lieur (ou tout autre outil). C'est ici qu'intervient la section [GroupFormats].
Si le lieur nécessite que les fichiers objet soient transmis via la ligne de commande sous la forme "a + Nom1.obj + Nom2.obj", etc., une clé doit être ajoutée dans la section [GroupFormats]. Elle indiquera à UEStudio le format requis. Par exemple la clé FGO prendra pour valeur “+ %s”. Dans certains rares cas, il se peut que le premier fichier de la liste n'ait besoin d'aucun format spécifique, ou utilise un format différent des autres fichiers. Vous pouvez alors spécifier un groupe de fichiers objet pour la ligne de commande : les différents objets pourront alors être séparés à l'aide de ",", tout en permettant la présence de la chaîne de caractères au début. Les nouvelles sections ressembleront à ceci :
[FileGroups]
FGO = .obj;
[GroupFormats]
FGO = , %s
FGO0 = /obj: %s (<= un zéro est ajouté à la définition de FGO pour que ce format soit utilisé pour le premier fichier du groupe)
Options de configuation [InsertFiles]
Certains compilateurs doivent pouvoir lier des fichiers particuliers lors de chaque génération d'une application. Une solution consiste à ajouter ces fichiers (par exemple des objets avec le code de démarrage) à chaque fois qu'un nouveau projet est créé. Une solution plus simple consisterait à définir ces fichiers dans des fichiers de configuration qui seraient toujours ajoutés au projet (uniquement lors de la génération). Si cela s'avère nécessaire, créez une nouvelle section [InsertFiles]. Deux types de clé peuvent être utilisés pour définir ces fichiers : file0 à fileX qui prendront pour valeur le chemin complet/relatif vers le fichier autonome, ou “group0” à “groupX” qui prendront pour valeur une liste de fichiers séparés par des espaces, par ex. “lib1.lib lib2.lib”, etc. Ces “groupes” peuvent également être utilisés dans la section [FileGroups] mentionnée plus haut. Si, par exemple, une liste de bibliothèques de "group0", défini dans la section [InsertFiles], doit être utilisée et ajoutée à la liste des fichiers objet, notre clé FGO modifiée de la section [FileGroups] deviendra :
[FileGroups]
FGO = .obj;group0;
Options de configuration [Variable] et [Environment]
N'importe quelle variable peut être définie et utilisée dans la plupart des clés de la plupart des sections - pratiquement partout où cela peut sembler opportun (il existe cependant une exception pour la clé TargetExt présente dans la section [General] - cette valeur ne peut pas être une “variable”.) La section primaire où vous pouvez définir vos variables se dénomme [Variable]. Vous pouvez par exemple y définir la clé CPATH qui pourra contenir le chemin complet vers le compilateur. Cette variable peut ensuite être utilisée dans les autres sections sous la forme $(CPATH). La plupart des compilateurs ont besoin d'un certain nombre de variables d'environnement comme INCLUDE, LIB, etc. La section [Environment] a été prévue à cet effet. Les clés qui y sont définies seront ajoutées à l'environnement normal lors de la génération. Il peut parfois être intéressant d'utiliser la valeur d'origine de la variable d'environnement, comme par exemple PATH (pour ajouter le chemin vers le compilateur) tout en conservant le chemin "courant". La valeur peut alors être définie de la manière suivante : “$(CPATH);%PATH%”. Veuillez noter que les valeurs d'origine (et ce uniquement pour cette section) peuvent être spécifiées sous la forme “%KEY%”, exactement comme vous l'auriez dans vos fichiers de configuration habituels. Il se peut également que vous ayez besoin d'inclure des informations de la base de registre dans ces deux sections. Pour ce faire, utilisez la syntaxe que nous venons de décrire en préfixant le nom avec HKEY, comme par exemple dans $(HKEY_CURRENT_USERMonCompilateurPath). Sa valeur sera donc prélevée à partir de la base de registre, depuis la clé Path du "dossier" MonCompilateur, dans la clé HKEY_CURRENT_USER. Pour utiliser la "Clé par défaut" du chemin MonCompilateur de la base de registre, utilisez la syntaxe $(HKEY_CURRENT_USERMonCompilateur@).
Options de configuration [Settings], [SettingsInfo] et [SettingsReps]
When changes are made directly to a compiler configuration file, and the Make Configuration Local button is not pressed, these changes will be global (for all projects). There are some special sections that allow modification of options using the GUI - [Settings], [SettingsInfo], and [SettingsReps].
[Settings] est la plus importante des sections et toutes les clés s'y trouvant sont enregistrées avec le projet afin qu'elles puissent être modifiées dans UEStudio, sans que le fichier de configuration n'ait besoin d'être modifié. Grâce à ces sections "communes", il est possible de créer des fichiers de configuration avec les mêmes options pour tous les projets (par exemple pour toutes les applications Windows) et les éléments paramétrables peuvent être définis ici. Si la clé Options du compilateur est créée dans la section [Settings] et que vous lui attribuez une chaîne vide comme valeur, cette clé sera vide par défaut, mais lorsqu'une valeur est définie, elle sera utilisée partout où vous spécifierez $(Options du compilateur).
S'il existe des valeurs prédéfinies (par exemple avec une clé nommée Niveau d'avertissement), elles peuvent être définies de la manière suivante : “w1|w2|w3”. Les valeurs sont délimitées à l'aide du symbole spécial “|”. La première valeur de la liste sera utilisée comme valeur par défaut, "w1" dans notre exemple. Comme nous l'avons précisé plus haut, chaque modification effectuée ici depuis UEStudio (et non pas directement via le fichier de configuration) sera enregistrée avec le projet. Vous pourrez ainsi directement sélectionner une de ces trois valeurs depuis UEStudio, en cliquant sur la clé Niveau d'avertissement.
Il serait cependant plus simple de pouvoir choisir une valeur parmi des éléments comme “Erreurs uniquement”, “Standard”, “Avertissements en erreurs”. Vous pouvez utiliser à cet effet la section [SettingsReps]. Nous pourrons alors définir la clé Niveau d'avertissement de la section [Settings] à l'aide des éléments “Erreurs uniquement|Standard|Avertissements en erreurs". Dans la section [SettingsReps], la clé Niveau d'avertissement sera définie de la manière suivante : “Erreurs uniquement=w1|Standard=w2|Avertissements en erreurs=w3”. UEStudio remplacera toutes ces options "orientées mots" par les options de ligne de commande correspondantes.
Il peut également arriver que des options doivent être transmises au compilateur sous une forme particulière. Si, par exemple, la ligne de commande du lieur doit être ajoutée sous la forme d'un script de ressource en paramètre, nous devrons alors créer une clé dans la section [Settings], par exemple Script de ressource. La ligne de commande du lieur ressemblera à ceci : “/rscript:$(Script de ressource)”. Vous ne rencontrerez aucun problème si Script de ressource est toujours défini, mais si ce n'est pas le cas, une erreur peut survenir lorsque Script de ressource contient une chaîne vide. La ligne de commande deviendrait alors “/rscript:”.
Pour éviter cela, il est préférable de créer la clé Script de ressource dans la section [SettingsReps] et lui attribuer la valeur “@/rscript:%s”. En débutant la liste des éléments par un “@”, nous indiquons à UEStudio qu'il s'agit d'un “format” : si la clé n'est pas définie, rien ne doit être transmis à la ligne de commande du lieur. Si, au contraire, la clé est définie, “/rscript:Script.ext” (ou la valeur) sera transmis.
Plutôt que d'obliger l'utilisateur à se remémorer toutes les options possibles, une section contenant toutes les informations relatives aux clés peut être créée. Ces informations seront affichées dans la boîte de dialogue des options du compilateur dans UEStudio, lorsque la clé est sélectionnée. Dans cette section, nommée [SettingsInfo], les clés listées doivent avoir le même nom que dans les sections [Settings] et [SettingsReps]. Les valeurs de ces clés contiendront le descriptif de chacune des clés. La nouvelle section [Settings] ressemblera maintenant à ce qui suit :
[Settings]
Target =
Working Directory =.
Niveau d'avertissement = Erreurs uniquement|Standard|Avertissements en erreurs
[SettingsReps]
Niveau d'avertissement = Erreurs uniquement=w1|Standard=w2|Avertissements en erreurs=w3
[SettingsInfo]
Target = emplacement où vous spécifiez le nom du fichier cible
Working Directory = ce dossier (si défini) sera celui à partir duquel l'application sera lancé
Niveau d'avertissement = vous pouvez définir ici le niveau d'avertissement de votre compilateur
Deux des clés de la section [Settings] définie ci-dessus sont présentes dans toutes les sections [Settings] des configurations de compilateur et l'une d'entre elles - Target - est obligatoire. Nous vous conseillons de la conserver vide : le nom de la cible sera alors généré à partir du nom du projet et TargetExt sera défini dans la section [General].