Petit turoriel sur le fonctionnement des Makefile s, cet article est exrait d’un zine canadien, il a ete ecrit par acidmen, plutot interessant pour ceux qui commence a faire des gros programmes…
Voir la suite …
Pr?sentation des makefiles.
Vous aurez s?rement remarqu? le makefile livr? avec un programme lorsque vous
l'avez compil?. ?tant donn? le niveau de complexit? pouvant ?tre atteint par un
fichier make, vous pouvez ? juste raison vous demander : "pourquoi utiliser
make?"
Si vous imaginez un instant un projet compos? de dizaine, voir de centaines de
modules, vous n'?tes sans doute pas tr?s impatient de recompiler tous ces
modules chaque fois que vous modifiez une ligne de code. Imaginez que vous
devriez recompiler enti?rement votre noyau ? la main apr?s une petite
modification du code source. Il serait extr?mement difficile de d?terminer les
compilations ? omettre, et l'omission de la compilation indispensable
entra?nerait des probl?mes. C'est pourquoi la commande make est pr?cis?ment
destin?e ? ce genre de travail.
La commande make est capable de tirer des conclusions sur les d?pendances
existantes entre divers fichiers. Elle poss?de d'autres fonctionnalit?s qui la
rendent tr?s puissante: elle sait d?finir des macros et des cibles
suppl?mentaires qui vous permettront d'?tre plus efficace.
Autre avantage des processus make : les instructions de compilation sont
enregistr?es dans le fichier make. Par exemple, il n'est pas n?cessaire de
m?moriser tous les param?tres de ligne de commande utilis?s pour un projet.
Mieux encore, il n'est pas n?cessaire de documenter ? l'intention d'autrui ce
qui vous a servi ? construire ce projet.
>> Le Makefile
Lorsque vous lancez la commande make sans d?signer explicitement un fichier
make sur la ligne de commande ( avec le param?tre -f), l'utilitaire GNU make
recherche trois noms de fichiers par d?faut dans le r?pertoire en cours, dans
l'ordre suivant :
1. GNUmakefile
2. makefile
3. Makefile
>> Nommer le Makefile
Makefile
Le nom Makefile avec la premi?re lettre en majuscule convient le mieux,
car lorsque vous listez vos fichiers, il figure en d?but de la liste.
GNUmakefile
La documentation de GNU make conseille d'?viter d'employer le nom de
fichier GNUmakefile. Vous ne devez l'utiliser que si vous vous servez
des foncionnalit?s g?r?es par la commande GNU make. Si le groupe de
fonctionnalit?s employ?es est celui make UNIX standard, pr?f?rez
Makefile ou makefile.
makefile
Lorsque le nom Makefile normal( avec un "M" majuscule) est utilis?, il
vous reste une possibilit? pr?alable. Si vous t?l?chargez un paquetage
de sources de l'Internet, mais d?couvrez que vous avez besoin de
modifier le Makefile fourni, vous pouvez tester vos modifications sans
toucher ? ce Makefile:
1. Recopiez Makefile en makefile.
2. Editez makefile selon vos besoins.
3. Lancez la commande make. C'est makefile qui est utilis? ? la
place de Makefile, car il est choisi en premier lorsqu'il existe.
>> Les cibles des Makefile
La commande make commence par la notion de cible.
Lorsqu'elle poss?de un fichier make, la commande make doit traiter au moins une
cible de ce fichier, sinon rien ne se passe ; et si le fichier ne contient
aucune cible, la commande make se plaint de la situation :
|#| bash$ make
|#| make: *** No targets. Stop.
|#| bash$
>> D?finir les cibles
Le listing 1.0 suivant pr?sente un Makefile tr?s simple pourvu de trois cibles,
one, two, three, aux ligne 4, 7 et 10. Un nom de cible commence toujours au
d?but d'une ligne et est suivi du caract?re deux-points.
_= Listing (1.0) Makefile simple comportant trois cibles =_
|#| 1: # Source: /home/acidmen/make/RCS/Makefile,v $
|#| 2:
|#| 3:
|#| 4: one:
|#| 5: @echo One
|#| 6:
|#| 7: two:
|#| 8: @echo two
|#| 9:
|#| 10: three:
|#| 11: @echo three
|#| 12:
|#| 13: # End Makefile
>> Invoquer les cibles de Makefile
Pour invoquer une cible, il suffit d'indiquer son nom sur la ligne de commande.
Par exemple, la commande suivante invoque la cible two:
|#| bash$ make two
|#| Two
|#| bash$
Dans cette exemple, make ignore totalement les cibles one et three.
>> Invoquer plusieurs cibles
Vous pouvez ?galement invoquer plusieurs cibles sur une m?me ligne
de commande:
|#| bash$ make three one two
|#| Three
|#| One
|#| Two
|#| bash$
Remarquez que les cibles sont trait?es dans l'ordre des arguments de la
ligne de commande.
>> Les cibles par d?faut
La commande make suppose que la toute premi?re cible rencontr?e dans le
fichier make est la cible par d?fault. Consid?rez l'exemple suivant :
|#| bash$ make
|#| One
|#| bash$
make invoque la premi?re cible rencontr?e, one, ? la ligne 4 du listing (1.0).
Les noms de cible two et three sont consid?r?es comme cibles de remplacement et
ne sont pas invoqu?es.
>> Les noms de cible standards
Bien qu'aucun standard formel n'existe pour les noms de cibles, vous
rencontrerez quelques conventions tr?s r?pandues lorsque vous examinerez les
fichiers make de sources publiquement t?l?chargeables.
[*] _all_ est souvent utilis? comme la premi?re cible et par cons?quent celui
par d?faut. Il sert habituellement ? nommer les vrais noms de cibles, qui
peuvent ?tre une ou plusieurs autre cibles, qui peuvent ?tre une ou plusieurs
autres cibles. En utilisant cette cible, vous construisez le projet entier.
[*] _install_ est normalement employ? pour installer un projet construit, dans
ses r?pertoires dus syst?me Linux, avec les autorisations correctes et les
r?gles de propri?t?, en cr?ant les sous-r?pertoires si n?cessaire.
[*] _clean_ est souvent utilis? pour vous permettre de supprimer tous les
fichiers objet (*.o), les fichiers core, et les autres fichiers provisoires qui
ont pu ?tre cr??s lors de la construction. Cette cible laisse les ex?cutables
et les biblioth?ques construits en place.
[*] _clobber_ est souvent utilis? pour supprimer les cibles construitent
du projet (en g?n?ral, les ex?cutables et les biblioth?ques). Vous supprimez
ces cibles pour reconstruire les fichiers de configuration du projet, etc.
[*] _distclean_ est souvent utilis? par les d?veloppeurs Linux et GNU pour
nettoyer compl?tement le fichier du projet, sauf en ce qui concerne les
fichiers d'origine distribu?s sur l'Internet. D?passant clobber, cette cible
supprime les fichiers de configuration du projet, etc.
>> Les d?pendances
On accepte couramment des d?pendances entre certains noms de cibles.
En tant que programmeur( ou progGameur? peut importe;), vous devez savoir que :
[*] La cible install d?pend habituellement de all.
[*] La cible clobber d?pend habituellement de clean.
[*] La cible distclean d?pend habituellement de clobber.
Si install d?pend de la cible all, le projet est d'abord construit, si
n?cessaire, puis l'installation tent?e. Sinon, il n'existe aucun projet ?
installer. Cependant, les logiciels sont souvent install?s avec les privil?ges
de root, il n'est par cons?quent pas souhaitable de construire votre projet
lorsque vous op?rez sous root. Si vous vous en sentez capable, vous pouvez
omettre cette d?pendance dans votre projet.
La cible clobber d?pend de clean, g?n?ralement par commodit?. La cible clean
s'occupe d'une partie du travail et il vous suffit de d?finir le reste pour
clobber. La cible distclean fonctionne sur le m?me principe.
>> D?finir les d?pendances
Le listing (2.0) pr?sente un nouveau fichier make auquel ont ?t? ajout?es des
d?pendances. La cible three d?pend de la cible two (ligne 10), et la cible two
d?pend ? pr?sent de la cible one (ligne 7). Remarquez que les d?pendances sont
simplement indiqu?es apr?s le nom de la cible et le carat?re deux-points. Les
d?pendances suppl?mentaires sont s?par?es par un ou plusieurs espaces. Au moins
un espace doit s?parer le caract?re deux points de la prmi?re d?pendances.
_= Listing (2.0) Makefile avec d?pendances=_
|#| 1: #Source: /home/acidmen/make/RCS/Makefile,v $
|#| 2:
|#| 3:
|#| 4: one:
|#| 5: @echo One
|#| 6:
|#| 7: two: one
|#| 8: @echo Two
|#| 9:
|#| 10: three: two
|#| 11: @echo Three
|#| 12:
|#| 13: # End Makefile
>> Tester les d?pendances des cibles
A pr?sent, lorsque vous invoquez le fichier make du Listing (2.0) avec le nom
de cible three, vous constatez que la commande make traite en r?alit? les trois
cibles:
|#| bash$ make three
|#| One
|#| Two
|#| Three
|#| bash$
Cet ordre vous surprend-t-il? La cible est ex?cut?e la premi?re, car la cible
two d?pend d'elle, et la cible three d?pend de two. Par cons?quent, avant de
pouvoir faire quoi que ce soit pour la cible three, ses d?pendances doivent
?tre satisfaites. Bien que la cible invoqu?e soit three, la cha?ne des
d?pendance est tell que make doit invoquer one en premier pour satisfaire les
deux autres cibles.
>> D?finir les macros de make
La puissance des scripts shell tient en partie ? leur capacit? d'utiliser et de
manipuler des variables shell et des variables d'environnement. La commande
make poss?de ce genre de fonctionnalit? et sait ?galement utiliser les
variables d'environnement.
Une macro make peut contenir une valeur de cha?ne comme un nom de fichier ou
une valeur de param?tre. Une macro permet de ne d?finir qu'une seule fois une
certaine valeur dans le Makefile, tout en permettant de l'utiliser dans
plusieurs endroits. Lorsqu'une modification est n?cessaire, il suffit de
modifier l'affectation de la macro, et elle appara?t imm?diatement partout o?
la macro est utilis?e.
Le listing (3.0) pr?sente une nouvelle ?dition du Makefile de d?monstration. La
ligne 5 montre comment d?clarer une macro OBJECT et initialiser sa valeur ?
"Pear". Vous supprimez ?galement les d?pendances pr?alablement utilis?es et
ajoutez un nom de cible par d?faut plus conventionnel, all, ? la ligne 7.
Remarquez que cette cible d?pend de trois cibles, on, two, three. Un projet
important est souvent structur? de cette fa?on dans un fichier make.
_= Listing (3.0) Makefile avec une d?finition de macro=_
|#| 1: # Source: /home/acidmen/make/RCS/Makefile,v $
|#| 2: # Revision: 1.3 $
|#| 3:
|#| 4:
|#| 5: OBJECT= Pear
|#| 6:
|#| 7: All: one two three
|#| 8:
|#| 9: one:
|#| 10: @echo one $(OBJECT)
|#| 11:
|#| 12: two:
|#| 13: @echo Two $(OBJECT)s
|#| 14:
|#| 15: three:
|#| 16: @echo Three $(OBJECT)s
|#| 17:
|#| 18: # End Makefile
Les lignes 10, 13 et 16 montrent un exemple d'utilisation de la valeur de la
macro. Elle est substitu?e au signe $ et au nom de la macro qui suit entre
parenth?ses. Les parenth?ses ne sont pas n?cessaires lorsque le nom de la macro
ne comporte qu'une lettre, par exemple $x. Il est cependant conseill?
d'utiliser des noms de macro significatifs. A pr?sent, invoquez ce fichier make
et observez son r?sultat.
|#| bash$ make
|#| One Pear
|#| Two Pears
|#| Three Pears
|#| bash$
Remarquez la substitution par la valeur. Notez aussi que la cible de la ligne 7
ne comporte aucune instruction. Cette ligne ne sert qu'? relier une cible aux
autres d?pendances.
>> Supplanter les valeurs d'une macro
La commande make permet ?galement de passer outre la valeur d'une macro.
Avec le fichier make du listing (2.0), vous ex?cuter :
|#| bash$ make OBJECT=apple
|#| One apple
|#| Two apples
|#| Three apples
|#| bash$
La ligne 5 affecte la valeur "Pear" ? la macro OBJECT, mais l'affectation de la
ligne de commande "OBJECT=apple" est prioritaire. On peut donc dire que la
commande make effectue d'abord toute les affectations de macros dans le fichier
make, puis celles ?ventuellement rencontr?es sur la ligne de commande.
>> Utiliser les variables d'environnement
La commande make peut ?galement prendre des valeurs de l'environnement. En
utilisant une nouvelle fois le fichier make du listing (3.0), voyez si vous
pouvez ?craser une macro avec une variable d'environnement export?e :
|#| bash$ OBJECT=walnut make
|#| One Pear
|#| Two Pears
|#| Three Pears
|#| bash$
C'est ?tonnant, ce test semble ne pas fonctionner, En r?alit?, les variables
d'environnement n'?crasent pas les affectations de macros d'un fichier make. Si
la macro OBJECT n'avait pas ?t? d?finie dans notre fichier make, la
substitution aurais ?t? effectu?e. Pour preuve, mettez la ligne 5 du listing
(3.0) en commentaire et essayez de nouveau.
|#| bash$ OBJECT=walnut make
|#| One walnut
|#| Two walnuts
|#| Three walnuts
|#| bash$
`
Cette fois, aucune affectation de macro ne figurant dans le Makefile, la valeur
de la variable d'environnement OBJECT demeure et est utilis?e comme attendu.
_= Listing (4.0) Makefile avec l'affectation de la macro mise en commentaire=_
|#| 1: # Source: /home/acidmen/make/RCS/Makefile,v $
|#| 2: # Revision: 1.3 $
|#| 3:
|#| 4:
|#| 5: #OBJECT= Pear
|#| 6:
|#| 7: All: one two three
|#| 8:
|#| 9: one:
|#| 10: @echo one $(OBJECT)
|#| 11:
|#| 12: two:
|#| 13: @echo Two $(OBJECT)s
|#| 14:
|#| 15: three:
|#| 16: @echo Three $(OBJECT)s
|#| 17:
|#| 18: # End Makefile
>> Utiliser le param?tre -e
Un param?tre de make, -e, permet ? l'environnement d'?craser les macros du
fichier make. Toutefois, utilisez-le prudemment, car l'environnement peut ?tre
modifi? bien plus que vous ne le pensez. En reprenant le fichier make d'origine
du listing vous pouvez tester cette r?gle :
|#| bash$ OBJECT=walnut make
|#| One Pear
|#| Two Pears
|#| Three Pears
|#| bash$ OBJECT=walnut make -e
|#| One walnut
|#| Two walnuts
|#| Three walnuts
|#| bash$
- Vous avez export? la variable d'environnement OBJECT et ex?cut? la
commande make, mais la variable OBJECT n'a aucun effet
- Vous avez exportez la variable d'environnement OBJECT une nouvelle
fois, mais ex?cutez ici make avec le param?tre -e. Cette fois, la
variable d'environnement OBJECT influence le r?sultat.
++ Lorsque vous comptez sur des variables d'environnement dans un
fichier make, assurez-vous qu'elles sont bien export?es de votre
shell. Assurez-vous ?galement de bien comprendre ce que la
commande d'exportation int?gr?e effectue dans le shell bash.
>> Les suffixe de fichiers
La commande make est tr?s largement d?pendante des suffixes de fichiers,
desquels elle d?duit le type du fichier. Gr?ce ? des conventions, elle peut
appliquer des r?gles de d?duction par d?faut. Avant d'?tudier ces r?gles,
regardons quelques suffixes connus de make, dans le tableau (1.0)
Tableau (1.0)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
> Suffixe de fichier < | > Description <
- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
] .c | Module source en langage C [
] .h | Fichier d'en-t?te en lengage C [
] .cc | Module source en langage C++ [
] .o | Fichier objet compil? [
- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
>> Comprendre les r?gles de d?duction
La puissance de la commande make propose en partie sur ces r?ges de d?ductions.
Mais ceux-ci peuvent ?tre une source de frustration lorsqu'elles ne sont pas
bien comprises.
> Tester les r?gles de d?duction par d?fault
Ecrivez ce ptit programme - hello.c -
|#| 1: #include
|#| 2: int main(int argc, char **argv) {
|#| 3:
|#| 4: (void) argc;
|#| 5: (void) argv;
|#| 6:
|#| 7: PUTS("Hello World!");
|#| 8: return 0;
|#| 9: }
Bon, une fois votre programme ?crit, testez ensuite les r?gles de d?ductions
par d?fault de make, comment indiqu? dans le listing (4.5).
_= Listing (4.5) Tester les r?gles de d?duction de hello.o de GNU make=_
|#| 1: bash$ mkdir experiment
|#| 2: bash$ cd experiment
|#| 3: bash$ cp ../hello.c .
|#| 4: bash$ >Makefile
|#| 5: bash$ make hello.o
|#| 6: cc -c hello.c -o hello.o
|#| 7: bash$ type cc
|#| 8: cc is /usr/bin/cc
|#| 9: bash$ls -dl /usr/bin/cc
|#| 10: lrwxrwxrwx 1 root root 3 Dec 15 2002 /usr/bin/cc -> gcc
|#| 11: bash$
Voici les ?tapes de ce test :
1. Vous cr?ez un r?pertoire dans lequel travailler ( ligne 1 )
2. Vous passez dans ce r?pertoire ( ligne 2 )
3. Vous recopiez votre programme hello.c dans le r?pertoire en cours (ligne 3).
Remarquez que le r?pertoire source de hello.c peut ?tre diff?rent dans votre
cas.
4. Vous cr?ez un Makefile vide dans lequel make pourrat travailler ( ligne 4 ).
5. Vous invoquez make avec le Makefile vide dans le r?pertoire en cours (ligne 5)
Indiquez explicitement le nom de cible hello.o ? make, car le Makefile ne
contient aucune cible d?finie.
6. La commande make s'ex?cute, montrant que sa r?gle interne d?duit que hello.c
doit ?tre compil? par un compilateur C pour produire hello.o ( ligne 6 ).
7. Vous demandez au shell d'o? provient cc ( ligne 7 ). Le shell indique le nom
du chemin ? la ligne 8.
8. Vous invoquez la commande ls avec le param?tre -dl ( ligne 9 ) et d?couvrez
que la commande cc est un lien symbolique vers la commande gcc ( ligne 10 ).
Ind?pendamment du fait que la r?gle ne fournit pas les param?tres -D_GNU_SOURCE
et -Wall, tout se passe tr?s bien sans aucune aide de votre part. Ces r?sultats
pouvant ?tre l?g?rement diff?rents de ceux attendus, vous devez d?finir
explicitement une r?gle correspondant ? vos besoins.
>> D?finir une r?gle de d?duction
Le listing (5.0) pr?sente un fichier make de d?monstration contenant une r?gle
de d?duction.
_= Listing (5.0) Une r?gle de d?duction de make =_
|#| 1: CC = gcc
|#| 2: STD = _GNU_SOURCE
|#| 3:
|#| 4: .c.o:
|#| 5: $(CC) -c -Wall $(CFLAGS) -D$(STD) $< -o $@
La ligne 1 montre la fa?on conventionnelle de choisir votre compilateur dans un
fichier make, avec la macro CC. Ici, la macro pointe directement sur le
compilateur gcc. La ligne 2 d?finit la macro STD permettant de s?lectionner le
standard sous lequel le compiler. La cible de la ligne 4 est d'un type sp?cial:
elle est compos?e du suffixe du fichier d'origine et de celui du fichier cible.
En d?finissant une cible sous cette forme, vous d?finissez en r?alit? une r?gle
de d?duction destin?e ? make.
^
/
/
/ A ttention ------------------------------------------------------------
/_ _ _ _
/ Ne d?finissez jamais de d?pendance pour une r?gle de d?duction. La
/ commande make ignore les d?pendances des r?gles de d?duction. Sur
/__ _ certaines plates-formes UNIX, la r?gle n'est pas interpr?t?e comme
une r?gle de d?duction lorsque des d?pendances sont indiqu?es
---------------------------------------------------------------------
La ligne 4 d?finit une r?gle de d?duction indiquant que si vous dispoez d'une
cible constitu?e d'un fichier objet (*.o) et constatez que vous disposez du
fichier d'entr?e correspondant avec le suffixe .c, vous ex?cutez les
instructions qui suivent.
>> Instruction ? ex?cuter
La ligne 5 du listing (5.0) repr?sente la seule instruction ? ex?cuter. Une
instruction doit commencer par un caract?re de tabulation. Les espaces ici sont
interdites. Il peut y avoir plusieurs actions, mais une seule est n?cessaire.
Notez ?galement que si la commande de l'action commence par un caract?re "@",
make supprime l'affichage de la commande sur la sortie standard. Vous l'avez
peut-?tre remarqu? aux lignes 5, 8 et 11 du listing (2.0)
____
|| | || ||=== | _ |
|| | || ||= ||_| |
|| | | || |____|_ _ _ _ _ _ _ _ _ _ _ _ _ _ __ _ _ ______ _ _ _ _ _ _ _ __
Les lignes d'action d'un fichier make doivent commencer par une tabulation.
Certains ?diteurs insistent sur l'utilisation des blancs lorsque vous appuyez
sur la touche Tab. V?rifiez que le premier carat?re est bien le caract?re ASCII
de tabulation, sinon make ne l'accepte pas comme instruction ? ex?cuter.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - --- -- - - -- --
La ligne 5 du listing (5.0) d?crit une instruction de compilation faisant grand
usage des macros. La plupart sont ais?ment compr?hensibles.
Cela nous laisse deux macros d'aspect bizzare : "$<" et "$@".
>>Les macros int?gr?es
La commande make g?re au moins six macros int?gr?es. Celles-ci sont diff?rentes
des macros d?finies par l'utilisateur, car elles n'ont jamais besoin d'?tre
d?finies. Elles sont g?r?es en interne par la commande make et leur valeur
change en fonction des r?gles de d?duction.
Les plus importantes de ces macros sont pr?sent?es au Tableau (2.0)
Tableau (2.0)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
> Nom de macro < | > Description <
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
] $* | Cette macro fournit l'?l?ment nom de fichier du [
] | d?pendant actuel ( le suffixe ?tant supprimer [
] | [
] $@ | Cette macro fournit le nom complet, avec le [
] | suffixe de la cible actuelle. [
] | [
] $< | Cette macro fournit le nom de fichier d?pendant [
] | complet, avec le suffixe. [
] | [
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Dans la session ?tudi?e au listning (4.5), la ligne 5 d?signe hello.o comme
cible, Dans la r?gle de d?duction des lignes 5 et 6 du listing (5.0), les
valeurs du Tableau (3.0) ci-dessous devraient ?tre indiqu?es.
Tableau (3.0)
- - - - - - - - - - - - - - - - - - - - - - - -
> Nom de macro < | > valeur de la macro <
- - - - - - - - - - - - - - - - - - - - - - - -
] $* | "hello" [
] $@ | "hello.o" [
] $< | "hello.c" [
- - - - - - - - - - - - - - - - - - - - - - - -
Souvez-vous que ces macros int?gr?es ne poss?dent de valeur qu'? l'int?rieur
d'une r?gle de d?duction. La macro $< comporte une petite exception, et au
moins deux autre macros int?gr?es ont d'autres usages.
>> La macro CFLAGS
La macro CFLAGS est utilis?e pour contenir d'autres param?tres du compilateur
C. Si elle n'est pas d?finie dans le fichier make, vous avez la
possibilit? d'initialiser une variable d'environnement pour la session dec
compilation en cours.
> Utiliser CFLAGS ? partir du shell
Une habitude courante consiste ? utiliser la macro CFLAGS pour effectuer ( ou
non ) une compilation en mode d?bogage. Notez le d?roulement de cette proc?dure
dans cette exemple :
|#| bash$ rm hello.o
|#| export CFLAGS=-g
|#| bash$ make hello.o
|#| gcc -c -Wall -g -D_GNU_SOURCE hello.c -o hello.o
|#| bash$
Voici la proc?dure utilis?e ici :
1. Vous prenez soin de vous d?barrasser du dernier hello.o cr?? ( sinon, make ne
se sentira pas oblig? de le recr?er )
2. Vous d?finissez et exportez la variable d'environnement CFLAGS avec le
param?tre de mise au point de gcc -g.
3. A partir de maintenant, lorsque vous compilez, la commande make prend
automatiquement la valeur export?e de CFLAGS et l'applique ? la ligne de
commande ( Remarquez que le param?tre -g appara?t dans la commande gcc ).
On peut utiliser la m?me technique pour recompiler afin d'optimiser au lieu de
d?boguer. Ce petit truc s'av?re particuli?rement utile lorsque le Makefile se
trouve contr?l? par un RCS ; il n'est pas n?cessaire de le modifier.