Utilisation du makefile

bonjour a toi,

bien que ta question soit assez vaste et necessite plutot un cours
qu'un simple post, je vais essayer de te resumer le necessaire:

Le Makefile est avant tout une automatisation des commandes. Par
consequent il te faut deja bien comprendre comment on compile
du code C avant de t'y lancer.

Il fonctionne en ecrivant des regles de la forme suivante:

nom_regle: dependances_sur_1_seule_ligne
[TAB]commande1
[TAB]commande2

Les tabulations ([TAB]) sont tres importantes, sinon ca ne marchera pas.

Par exemple:

$ emacs Makefile

########## MAKEFILE FOR MON_BINAIRE
mon_binaire: main.c
[TAB] gcc main.c -o mon_binaire 
########## END MAKEFILE

$ make
gcc main.c -o mon_binaire
$ ./mon_binaire
$

Voila. Pour bien comprendre, la commande "make" regarde si il y a un fichier
"Makefile" ou "makefile" dans le repertoire courant et execute la premiere
regle qu'il rencontre (la regle "mon_binaire"). Ici, la dependance sur le fichier
source permet de ne recompiler que ce qui a ete modifie:

$ make
make: `mon_binaire' is up to date.
$ touch main.c
$ make
gcc main.c -o mon_binaire
$

Pour permettre une plus grande modularite, le format du Makefile gere des
variables, voila la syntaxe de declaration:

MA_VARIABLE = ma_1ere_ligne \
ma_2eme_ligne \
ma_3eme_ligne

par exemple:

################ MAKEFILE
NAME = mon_binaire

SRC = main.c malib.c \
other.c \
yet_another.c

$(NAME): $(SRC)
[TAB]$(CC) $(CFLAGS) $(SRC) -o $(NAME)

################ END MAKEFILE

$ make
gcc -Wall -ansi -pedantic -W main.c malib.c other.c yet_another.c -o
mon_binaire
$

D'autre part, il est possible d'appeler une regle particuliere en la passant en
parametre a make.
Par consequent, dans notre cas "make" est equivalent a "make mon_binaire".

Enfin le Makefile gere aussi des mecanismes plus complexes de regles de
compilation implicites, et est surtout utile pour la compilation separee.
Terminons sur un exemple commente un peu plus complet:

########### MAKEFILE
NAME = mon_binaire

SRC = main.c file.c

# je declare les fichiers objets comme etant les fichiers sources avec
# une extension ".o" au lieu de ".c"
OBJ = $(SRC:.c=.o)

CC = gcc

CFLAGS = -Wall -ansi -pedantic -W -O3

RM = rm -f

all: $(NAME)

# Cette regle ne sert qu'au linkage, on marche en compilation separee
$(NAME): $(OBJ)
[TAB] $(CC) $(CFLAGS) $(OBJ) -o $(NAME)

# Cette regle est facultative car implicite: make sait transformer
#un .c en .o par lui-meme mais je la precise pour un but educatif :)
.c.o:
[TAB] $(CC) $(CFLAGS) -c $<

# Cette regle efface les fichiers objets et les fichiers temporaires
# de emacs :)
clean:
[TAB] $(RM) $(OBJ)
[TAB] $(RM) $~ \#*

# Celle-ci est a utiliser avant de distribuer les sources. Elle efface
# aussi le binaire
distclean: clean
[TAB] $(RM) $(NAME)
########### END MAKEFILE

$ make
gcc -Wall -ansi -pedantic -W -O3 -c main.c
gcc -Wall -ansi -pedantic -W -O3 -c file.c
gcc -Wall -ansi -pedantic -W -O3 main.o file.o -o mon_binaire
$ ./mon_binaire
$ ls *.o
file.o main.o
$ make clean all
rm -f main.o file.o
rm -f \#*
gcc -Wall -ansi -pedantic -W -O3 -c main.c
gcc -Wall -ansi -pedantic -W -O3 -c file.c
gcc -Wall -ansi -pedantic -W -O3 main.o file.o -o mon_binaire
$ make distclean
rm -f main.o file.o
rm -f \#*
rm -f mon_binaire
$

Voila, j'espere que tu as eu les reponses que tu attendais.
Je reste a ta disposition si tu as encore besoin d'aide.

-- 
Loomchild - ecchi nano wa ikeru to omoimasu