Compilation, compiler.
La compilation est l'action de compiler. Compiler signifie transformer un fichier texte lisible par un être humain initié, en un fichier directement exécutable par un ordinateur. Généralement, quand on dit compiler, on sous entend aussi la phase d'édition de liens, ce qui est un abus de langage. Cet abus est justifié par le fait que, sous Linux et dans l'environnement Unix en général, pour faire une compilation (au sens strict) et une édition de liens, on va lancer le même programme (gcc, g++ par exemple), mais avec des paramètres différents. La compilation, au sens strict du terme, produit des fichiers ayant l'extension '.o'. Je vous invite à consulter la documentation de gcc, ou plus exactement d'egcs, à http://gcc.gnu.org/.

Compilation conditionnelle.
Il est possible d'adapter la compilation à différents cas de figure au moyen de la compilation conditionnelle. En fait, la compilation s'effectue en plusieurs passes, c'est à dire que le compilateur est constitué de plusieurs programmes appelés les uns après les autres, chacun travaillant sur les fichiers produits par son prédécesseur. La première passe s'appelle la précompilation. Elle est effectuée par le précompilateur qui va évaluer les directives de compilation (les mots précédés par '#'). Parmi ces directives de compilation se trouvent #if, #else et #endif. Ce sont ces directives qui vont permettre de s'adapter à différents cas. Exemple :

#if defined(DEBUG)
printf("le code retour est %d\n",rc);
#endif
...
#if defined(__i386__)
convertir_en_gros_boutiste(&entier);
#endif

On rencontrera aussi #ifdef à la place de #if defined(...) . La forme #if defined permet de combiner les tests dans des expressions logiques comme #if (defined(DEBUG) && (__i386__ == 1)).
L'exemple précédent si les constantes (ou macros) sont définies. Pour les définir, il existe plusieurs solutions  :

Certaines constantes sont prédéfinies par le compilateur. Elles servent généralement à identifier le compilateur, l'OS et le microprocesseur.

La compilation conditionnelle est fortement utilisée dans les programmes "open source" car ces programmes sont censés pouvoir être compilés dans différents environnements (LinuxPPC bien sûr, mais aussi les différents Unix des constructeurs, '*BSD', et d'autres) qui peuvent exister sur différentes plate-formes (Macintosh, Alpha, Sparc, SGI, ...).

Encore un petit mot sur les constantes. On les appelle aussi macros car on peut définir des choses comme ceci :

#define MAX(a,b) ((a) < (b) ? (b) : (a))

ce qui ressemble assez aux fonctions-formules du FORTRAN (mais je m'égare ... ;-). A chaque fois que le précompilateur va rencontrer la "fonction" MAX, il la remplacera par sa définition.


Edition de liens.
En fait, le compilateur ne produit pas du code exécutable. En effet, dans un programme aussi simple que le suivant :

#include <stdio.h>
int main(int argc, char **argv)
{
   printf("Bonjour tout le monde !\n");
}

le compilateur sait que la fonction printf de la bibliothèque standard du C existe, mais il est incapable d'en incorporer le code à notre programme car il ne sait pas où le trouver. Il va l'indiquer comme référence à résoudre par l'éditeur de liens (qu'on appelle aussi link, linker ou link edit; effectuer l'édition de lien se dit aussi "linker"). L'éditeur de lien va scruter tous les fichiers (produits de compilation et bibliothèques) qu'on lui passe en paramètre pour y rechercher les références à résoudre laissées par le compilateur et va effectuer les liens nécessaires entre les références à résoudre et le code correspondant dans les bibliothèques. Une fois ce travail terminé, le code produit est directement exécutable par un ordinateur.


Bibliothèque.
Une bibliothèque (en en anglais : library, et qui est "traduit" dans 99,99% des cas par librairie) est un fichier qui contient le code exécutable de fonctions diverses et variées, que tout programmeur peut réutiliser. Sous Linux, il existe 2 sortes de bibliothèques : les bibliothèques statiques et les bibliothèques dynamiques. Le nom d'une bibliothèque commence par 'lib', et se termine par '.a' (statique) ou '.so' (dynamique). A chaque bibliothèque correspond un ou plusieurs fichiers à inclure (extension '.h') qui contiennent les définitions des fonctions de la bibliothèque, et qui seront utilisés par le compilateur (au sens strict). Les bibliothèques sont utilisées par l'éditeur de liens.

Le code des bibliothèques statiques est incorporé au programme que l'on compile lors de la phase d'édition de liens. Dans le cas des bibliothèques dynamiques, en revanche, l'éditeur de liens va indiquer dans le code exécutable du programme que telle fonction se trouve dans telle bibliothèque dynamique, et le code correspondant ne sera pas incorporé au programme. Les bibliothèques dynamiques existent sous MacOS. Ce sont les bibliothèques partagées (ou shared libraries en anglais).


make, makefile
Make est un outil standard de l'environnement de développement C/C++. Il va permettre d'enchainer les étapes de fabrication d'un programme (compilation, édition de liens, autres) au moyen d'un fichier qui les décrit : le fichier Makefile. Par défaut, make recherche dans le répertoire courant le fichier qui porte le nom Makefile, mais on peut donner un autre nom à ce fichier.

Un fichier Make file est consitué de plusieurs paragraphes comme le suivant :


cible: liste de dépendances
   actions à réaliser pour faire cible à partir de la liste de dépendances

Dans la liste de dépendances, on trouve d'autres cibles et des fichiers.

Un Makefile minimal pourrait ressembler à ceci :


all: toto

toto: toto.o
   gcc toto.o -o toto

toto.o: toto.c
   gcc -O2 -c toto.c

clean:
   rm -f *.o *~ toto

install:
   cp -f toto ~/bin/.

Dans ce fichier Makefile, on indique que l'on veut obtenir le fichier toto. On a précisé que ce fichier se fabrique à partir du fichier toto.o par la commande gcc toto.o -o toto (édition de liens). On a aussi spécifié que toto.o se fabrique à partir du fichier toto.c par l'action gcc -O2 -c toto.c (compilation). On a aussi donné deux autres cibles : clean pour nettoyer le répertoire de développement, et install pour recopier l'exécutable toto dans un répertoire particulier. On remarque sur cet exemple qu'une cible peut correspondre à un fichier, mais que ce n'est pas obligatoire.

Quand on passera la commande make, make lira le fichier Makefile et cherchera la cible all. Make va alors rechercher la cible toto, puisque l'on a indiqué qu'all consiste à faire toto. Si le fichier toto existe, make s'arrête. Sinon, make va rechercher la cible toto. On a indiqué que toto se fait à partir de toto.o. Si le fichier toto.o existe, make va effectuer l'opération gcc toto.o -o toto. Si le fichier toto.o n'existe pas, make va rechercher la cible toto.o et ainsi de suite. En fait, c'est un peu plus compliqué que ça, car make va comparer aussi les dates de dernière modification des fichiers. Ainsi, si les fichiers toto, toto.o et toto.c existent, et que toto.c est plus récent que toto.o, make refera toto.o, puis, comme toto.o sera plus récent que toto, make refera toto.

On peut indiquer à make, sur la ligne de commande, une cible à réaliser (make clean, make toto.o). On peut aussi préciser le nom du fichier Makefile (make -f toto.make).

Je vous invite à lire la documentation de make à http://www.gnu.org/software/make/manual/make.html.


autoconf
Autoconf est un outil qui produit des scripts shell qui configurent automatiquement les paquetages de code source afin de les adapter à toutes sortes de système de type UNIX. Autoconf produit le script configure à partir du fichier de description configure.in. Voyez la page d'info d'autoconf à ce sujet (info autoconf).

imake
Imake est utilisé pour produire des fichiers Makefile à partir d'un schéma, c'est à dire un fichier, appelé Imakefile. Imake a donc la même fonction qu'autoconf. Imake est généralement appelé par la commande xmkmf. Voyez la page de man d'imake (man imake) et de xmkmf (man xmkmf).