Aspire One Linux debutant : La commande Make éxpliquée
16 views
Skip to first unread message
minux
Mar 5, 2009, 7:39:14 PM3/5/09
to Zone Aspire One
----------------------------------------------------------------------------------------------------------------------------------------------
-Ce tuto sur la comande Make.n'est pas de moi ,il fait partie des
copier-coller au fil de mes surf's -
-que je veux garder et
partager ;=)
-
----------------------------------------------------------------------------------------------------------------------------------------------
La commande MAKE
--------------------------------
Ce tutoriel s'adresse aux débutants programmeurs sous Linux. Il vous
présente la commande make et la création de fichier « makefile ». Je
précise sous Linux, mais sachez qu'ils existent aussi sous windows,
vous pouvez demander à VC++ de vous les construire.
Alors qu'est ce qu'un fichier makefile?
C'est un fichier nommé « makefile » qui permet, en ne tapant que «
make » , dans le répertoire où il se trouve de compiler tout votre
projet.
Par conséquent il rassemble toute les directives de compilation de
votre projet.
Vous imaginez bien qu'à partir d'un certain nombre de fichier source,
il devient tout à fait indispensable.
Imaginez-vous taper gcc fichier.c -Wall -c etc... pour chacun de vos
fichiers!!! Make fait tout :)
L'édition d'un fichier Makefile:
------------------------------------------
Un fichier « makefile » s'édite à l'aide d'un éditeur de texte. Je
vous conseille personnellement Xemacs.
Les Commentaires sont unilignes et commencent par #:
# commentaire...
Un tel fichier contient un ensemble de règle, un règle se compose de
la manière suivante:
cible : dépendances
<tab> commandes
rem : <tab> correspond à une véritable tabulation..
La cible est le fichier à construire, les dépendances sont les
fichiers dont on a besoin pour créer la cible. Les commandes sont les
commandes à exécuter pour générer la cible.
Prenons un exemple, pour créer un fichier *.o nous avons besoin d'un
fichier *.c et de fichiers *.h
main.o : main.c main.h autre.h
<tab> gcc main.c -c -Wall
Ici si le fichier make de contient que ça, le lancement de la commande
make va générer main.o.
L'intérêt de make réside dans le fait, qu'il ne reconstruit une cible
que si les dépendances ont et modifier depuis la dernière utilisation
de make, ou si la cible n'existe pas. Ce qui évite de tout recompiler
à chaque fois.
Pour construire une cible, make se relance récursivement. Ce qui fait
que l'ordre des règles importe peut.
Les macros:
------------------
Ce sont des variables de type chaîne de caractères.
Définition: MACRO = Valeur
Référence: $(MACRO) -> sert à son
utilisation
Exemple:
MODULE = main.o aux.o
main : $(MODULE)
<tab> gcc $(MODULE) -o main
Il en existe des prédéfinis: les macros internes
$@ Contient le nom de la cible
$* Contient de nom de la cible sans suffixe ( si
cible = main.c; $* = main)
$^ Contient le nom de toutes les dépendances
$? Liste des dépendances dont la date est
postérieure à la cible
$< Contient la dépendance qui a provoqué la
reconstruction de la cible
Les macros prédéfinies que l'on peut modifier:
$(CC) Contient le nom du
compilateur
$(CPPFLAGS) Liste des options de pré-processage
$(CFLAGS) Liste des options de compilation
$(LDFLAGS) Liste des options de pré-édition
des liens.
Un petit exemple pour illustrer tout ça :)
CC = gcc
CFLAGS = -Wall -O3
LDFLAGS = -lm
programme : main.o matrice.o
<tab> $(CC) $^ -o $@ $(LDFLAGS)
main.o : main.c matrice.h
<tab> $(CC) main.c -c $(CFLAGS)
matrice.o : matrice.h matrice.c
<tab> $(CC) $*.c -c $(CFLAGS)
Ici, l'exécution de la commande make, compilera le fichier 'programme
', en générant les fichiers *.o intermédiaires.
Remarque, le lancement de make ne génère que la première cible, et
génère les autres si ils en a besoin pour la construire.
Pour compiler une cible particulière, on lance make avec le nom de la
cible:
$ make matrice.o // Genère le fichier matrice.o
Les directives:
---------------------
Ce sont des options pour le make. Elles sont à placer dans le fichier
makefile.
En voici quelques unes:
.INIT : <commande à exécuter au début du make>
.DEFAULT : <commande à exécuter en cas d'erreur >
.DONE : <commande exécuter à la fin de make>
.IGNORE: Evite au make de
s'arrêter en cas d'erreur
.SILENT: N'affiche pas les
commandes exécutées
.PRECIOUS: <fichier>* Ne pas détruit pas les
fichiers ..
.PHONY : <cible>* Déclares les cibles qui
ne sont pas des fichiers
Exemple:
On veut créer une cible clean qui ne correspond pas à un fichier, qui
une fois appeler dans le make va nettoyer le dossier actuel. On
déclare donc clean comme cible non fichier.
.PHONY: clean
clean:
<tab> rm -f *.o
<tab> rm -f *~
Ainsi la commande $ make clean , va supprimer tous les fichiers *.o et
les fichier *~
En général on définie également une cible « all » qui regroupe toutes
les fichiers à produire.
De facon à ce que la commande $ make all construise tous les fichiers
désirés.
.PHONY: clean all
all: prog1 prog2 prog3
Ainsi, la commande $make all ordonne la compilation des 3 programmes.
Il reste encore beaucoup de chose à dire sur le makefile, mais je vous
laisse en regarder là doc, vous savez à présent le principal :).
Je termine ainsi par un exemple complet d'un projet devant générer
deux programmes:
# Début du make file
# Déclaration des macros
CC = gcc
CFLAGS = -Wall -O3
LDFLAGS = -lm
.PHONY: all clean
all : prog1 prog2
prog1 : main.o affichage.o lecture.o
<tab> $(CC) $^ -o $@ $(LDFLAGS)
prog2 : main2.o affichage.o matrice.o
<tab> $(CC) $^ -o $@ $(LDFLAGS)
main2.o : main2.c affichage.h matrice.h
<tab> $(CC) main2.c -c $(CFLAGS)
main.o : main.c affichage.h lecture.h
<tab> $(CC) main.c -c $(CFLAGS)
affichage.o : affichage.h affichage.c
<tab> $(CC) affichage.c -c $(CFLAGS)
# etc...
clean:
<tab> rm -f *.o
<tab> rm -f *~
La commande $make all, générera ainsi prog1 et prog2.
La commande $make prog2, ne générera que le prog2.
--------------------------------------------------------------------------------------------------------------------------------
Voila pour ce tuto sur la comande Make.il n'est pas de moi ,il fait
partie des copier-coller
que je veux garder et partager
A plua
-Ce tuto sur la comande Make.n'est pas de moi ,il fait partie des
copier-coller au fil de mes surf's -
-que je veux garder et
partager ;=)
-
----------------------------------------------------------------------------------------------------------------------------------------------
La commande MAKE
--------------------------------
Ce tutoriel s'adresse aux débutants programmeurs sous Linux. Il vous
présente la commande make et la création de fichier « makefile ». Je
précise sous Linux, mais sachez qu'ils existent aussi sous windows,
vous pouvez demander à VC++ de vous les construire.
Alors qu'est ce qu'un fichier makefile?
C'est un fichier nommé « makefile » qui permet, en ne tapant que «
make » , dans le répertoire où il se trouve de compiler tout votre
projet.
Par conséquent il rassemble toute les directives de compilation de
votre projet.
Vous imaginez bien qu'à partir d'un certain nombre de fichier source,
il devient tout à fait indispensable.
Imaginez-vous taper gcc fichier.c -Wall -c etc... pour chacun de vos
fichiers!!! Make fait tout :)
L'édition d'un fichier Makefile:
------------------------------------------
Un fichier « makefile » s'édite à l'aide d'un éditeur de texte. Je
vous conseille personnellement Xemacs.
Les Commentaires sont unilignes et commencent par #:
# commentaire...
Un tel fichier contient un ensemble de règle, un règle se compose de
la manière suivante:
cible : dépendances
<tab> commandes
rem : <tab> correspond à une véritable tabulation..
La cible est le fichier à construire, les dépendances sont les
fichiers dont on a besoin pour créer la cible. Les commandes sont les
commandes à exécuter pour générer la cible.
Prenons un exemple, pour créer un fichier *.o nous avons besoin d'un
fichier *.c et de fichiers *.h
main.o : main.c main.h autre.h
<tab> gcc main.c -c -Wall
Ici si le fichier make de contient que ça, le lancement de la commande
make va générer main.o.
L'intérêt de make réside dans le fait, qu'il ne reconstruit une cible
que si les dépendances ont et modifier depuis la dernière utilisation
de make, ou si la cible n'existe pas. Ce qui évite de tout recompiler
à chaque fois.
Pour construire une cible, make se relance récursivement. Ce qui fait
que l'ordre des règles importe peut.
Les macros:
------------------
Ce sont des variables de type chaîne de caractères.
Définition: MACRO = Valeur
Référence: $(MACRO) -> sert à son
utilisation
Exemple:
MODULE = main.o aux.o
main : $(MODULE)
<tab> gcc $(MODULE) -o main
Il en existe des prédéfinis: les macros internes
$@ Contient le nom de la cible
$* Contient de nom de la cible sans suffixe ( si
cible = main.c; $* = main)
$^ Contient le nom de toutes les dépendances
$? Liste des dépendances dont la date est
postérieure à la cible
$< Contient la dépendance qui a provoqué la
reconstruction de la cible
Les macros prédéfinies que l'on peut modifier:
$(CC) Contient le nom du
compilateur
$(CPPFLAGS) Liste des options de pré-processage
$(CFLAGS) Liste des options de compilation
$(LDFLAGS) Liste des options de pré-édition
des liens.
Un petit exemple pour illustrer tout ça :)
CC = gcc
CFLAGS = -Wall -O3
LDFLAGS = -lm
programme : main.o matrice.o
<tab> $(CC) $^ -o $@ $(LDFLAGS)
main.o : main.c matrice.h
<tab> $(CC) main.c -c $(CFLAGS)
matrice.o : matrice.h matrice.c
<tab> $(CC) $*.c -c $(CFLAGS)
Ici, l'exécution de la commande make, compilera le fichier 'programme
', en générant les fichiers *.o intermédiaires.
Remarque, le lancement de make ne génère que la première cible, et
génère les autres si ils en a besoin pour la construire.
Pour compiler une cible particulière, on lance make avec le nom de la
cible:
$ make matrice.o // Genère le fichier matrice.o
Les directives:
---------------------
Ce sont des options pour le make. Elles sont à placer dans le fichier
makefile.
En voici quelques unes:
.INIT : <commande à exécuter au début du make>
.DEFAULT : <commande à exécuter en cas d'erreur >
.DONE : <commande exécuter à la fin de make>
.IGNORE: Evite au make de
s'arrêter en cas d'erreur
.SILENT: N'affiche pas les
commandes exécutées
.PRECIOUS: <fichier>* Ne pas détruit pas les
fichiers ..
.PHONY : <cible>* Déclares les cibles qui
ne sont pas des fichiers
Exemple:
On veut créer une cible clean qui ne correspond pas à un fichier, qui
une fois appeler dans le make va nettoyer le dossier actuel. On
déclare donc clean comme cible non fichier.
.PHONY: clean
clean:
<tab> rm -f *.o
<tab> rm -f *~
Ainsi la commande $ make clean , va supprimer tous les fichiers *.o et
les fichier *~
En général on définie également une cible « all » qui regroupe toutes
les fichiers à produire.
De facon à ce que la commande $ make all construise tous les fichiers
désirés.
.PHONY: clean all
all: prog1 prog2 prog3
Ainsi, la commande $make all ordonne la compilation des 3 programmes.
Il reste encore beaucoup de chose à dire sur le makefile, mais je vous
laisse en regarder là doc, vous savez à présent le principal :).
Je termine ainsi par un exemple complet d'un projet devant générer
deux programmes:
# Début du make file
# Déclaration des macros
CC = gcc
CFLAGS = -Wall -O3
LDFLAGS = -lm
.PHONY: all clean
all : prog1 prog2
prog1 : main.o affichage.o lecture.o
<tab> $(CC) $^ -o $@ $(LDFLAGS)
prog2 : main2.o affichage.o matrice.o
<tab> $(CC) $^ -o $@ $(LDFLAGS)
main2.o : main2.c affichage.h matrice.h
<tab> $(CC) main2.c -c $(CFLAGS)
main.o : main.c affichage.h lecture.h
<tab> $(CC) main.c -c $(CFLAGS)
affichage.o : affichage.h affichage.c
<tab> $(CC) affichage.c -c $(CFLAGS)
# etc...
clean:
<tab> rm -f *.o
<tab> rm -f *~
La commande $make all, générera ainsi prog1 et prog2.
La commande $make prog2, ne générera que le prog2.
--------------------------------------------------------------------------------------------------------------------------------
Voila pour ce tuto sur la comande Make.il n'est pas de moi ,il fait
partie des copier-coller
que je veux garder et partager
A plua
Reply all
Reply to author
Forward
0 new messages