Mini-reference :
outil SCons

Contenu

1. SCons: introduction et scripts
2. Exemple de compilation
3. Pour en savoir plus

Introduction

SCons est un outil de construction de projets (compilation et génération d'exécutables). Il permet de gérer facilement la compilation de projets d'une certaine complexité. Il est capable d'identifier quels composants d'un projet doivent être recompiles, et ne recompiler que ces derniers.

SCons est développé dans le langage Python; écrire un fichier SCons revient donc a écrire des commandes spécifiques dans le langage Python (On appelle ce genre d'outils langages a domaine spécifique intégrés - embedded DSLs). Le grand avantage d'utiliser un tel outil est que l'on peut profiter de la puissance/expressivité de tout le langage Python.

Scripts

Lors d'un appel a la commande scons, l'outil cherche la présence d'un fichier script nommé SConstruct dans le dossier ou la commande est appelée. Le fichier SConstruct contient les instructions de build du projet. Ce dernier peut déléguer le build a des fichiers SConscript qui se trouvent dans des sous-dossiers du projet. Voici quelques variables et méthodes clefs pour écrire un fichier de build:

• env = Environment(): env est une variable qui fait référence a l'environnement de SCons. C'est un objet qui contient des méthodes utiles a la spécification d'un build.
• env.Program(target = '', source = ''): création d'une unité de compilation, outargetdécrit l'exécutable que l'on veut créer, etsource` les sources que l'on veut compiler (plusieurs sources peuvent être spécifiées a l'aide d'une liste).
• env.Append(variable = ...) : ajoute des variables de configuration a l'environnement. On peut par exemple spécifier CCFLAGS ou LINKFLAGS.
• 'env.Alias(nom, valeur)' : crée un alias nom pour la valeur donnée. Ceci permet d'exécuter ce qui est spécifie dans valeur en écrivant scons nom sur la ligne de commande.
• Glob(dossier/*cpp) : Glob permet de capturer, par expressions régulières, tous les fichiers d'un certain type, dans un certain dossier.
• SConscript('src/SConscript', variant_dir='build', duplicate=0) : permet de déléguer le build a un fichierSConscript. la variablevariant_dirdonne le dossier ou les fichiers compiles doivent être stockes, et la variableduplicate=0indique qu'il ne faut pas recopier les fichiers sources dansvariant_dir`.

La ligne de commande

• scons : démarre la compilation des fichiers spécifies dans SConstruct (et dans les SConscript indiques).
• scons -c : efface les fichiers crées par la compilation ( commande de nettoyage)
• scons -Q : mode silencieuse.
• scons --help : affiche une aide ainsi que d'autres options disponibles.

Exemple de compilation

Admettons que l'on ait écrit un programme implémentant une calculatrice pour nombres complexes, séparé en modules de la manière suivante :

• en plus de la librairie standard, on dispose d'une librairie graphique, LibGraph, sous la forme d'un fichier de déclaration, libgraph.h, et d'un fichier d'archive binaire, libgraph.a (statique) ou libgraph.so (dynamique).
• la modélisation des nombres complexes et de leur arithmétique, fournie par le fichier de déclaration complexe.h (header) et le fichier d'implémentation complexe.cc ;
• la modélisation de la calculatrice (fonctions de base, mémoire, parenthésage, etc.), fournie par les fichiers calculatrice.h, dépendant de complexe.h, et calculatrice.cc (sans dépendance) ;
• la modélisation de l'interface graphique de la calculatrice, fournie par les fichiers calcGUI.h, dépendant de calculatrice.h et de libgraph.h, et calcGUI.cc ;
• le programme principal (comprenant la fonction main()), fournit par le fichier calculCplx.cc, dépendant de calcGUI.h .

Les dépendances se traduisent dans nos fichiers par les directives d'inclusion #include ... Bien entendu, chaque fichier d'implémentation (.cc) dépend de plus du fichier de définition (.h) auquel il est associé.

Diagramme de compilation

Le grand avantage de Scons est que ce dernier est capable de trouver les dépendances de par lui-meme, et de compiler les fichiers dans l'ordre requis. Un script possible pourrait donc être :

import os

env = Environment()

env.Append(CCFLAGS='-std=c++0x -g3 -Wall -Wextra')
#inclusion de la libraire
env.Append(LINKFLAGS = ['-lgraph'])

#calculCplx
calculCplx = env.Program(target='calculCplx', src='calculCplx.cc')
env.Alias("calculCplx", calculCplx)

Avec le script ci-dessus, il suffit d'appeler scons calculCplx pour compiler les fichiers nécessaires. Supposons maintenant que nous voulions créer une bonne structure de dossiers pour notre projet, ou nous séparons les sources et les exécutables. Voici une structure possible du projet :

dossier_projet/
  SConstruct
  src/
    SConscript
    complexe.h
    complexe.cc
    calculatrice.h
    calculatrice.cc
    calcGUI.h
    calcGUI.cc
    calculCplx.cc
  test/
  lib/
    libgraph.h
    libgraph.a
    libgraph.o
  bin/
  build/

ou le contenu du fichier SConstruct est :

SConscript('src/SConscript', variant_dir='build', duplicate=0)

et celui du fichier src/SConscript est:

import os

env = Environment()

env.Append(CCFLAGS='-std=c++0x -g3 -Wall -Wextra')
#inclusion de la libraire
env.Append(LINKFLAGS = ['-lgraph'])

#calculCplx
calculCplx = env.Program(target='../bin/calculCplx', src='calculCplx.cc')
env.Alias("calculCplx", calculCplx)

En savoir plus

SCons contient bien plus d'options qui peuvent être très utiles. Voici quelques liens qui permettent d'en apprendre plus (ou d'assoir les bases):

• L'exercice niveau 0 de la série 17
• Guide d'utilisation: document très détaillé sur l'utilisation de SCons.
• Exemples: quelques recettes de cuisine pour des taches communes.
• API (pour les fans): l'API complet de SCons, donne toutes les méthodes et objets que l'on peut utiliser pour écrire des fichiers SCons.