Aller au contenu

makefile

Soulfly_tribe90

Par Soulfly_tribe90
dans Programmation et Lignes de code

Messages recommandés

Soulfly_tribe90 Régulier

Soulfly_tribe90

Posté(e)
Posté(e)

En fait je voulais savoir comment je peux faire pour structurer un projet avec un makefile => genre avoir un dossier bin, headers, src et obj.

j'ai réussi à faire les 3 premiers mais impossible de rediriger les .o dans un dossier.

Voilà mon makefile donc si quelqu'un a une idée :reflechis:

CC=gcc
CFLAGS=-Wall -Iheaders
LDFLAGS=-Wall -lm
EXEC=bin/mainTest
VPATH=src
vpath %.h headers
SRC=$(wildcard src/*.c)
OBJ=$(notdir $(SRC:.c=.o))

mainTest : $(OBJ)
@ $(CC) -o $(EXEC) $(OBJ) $(LDFLAGS)
@echo creation de lien

%.o:%.c
@ $(CC) -c $< $(CFLAGS)
@echo creation de $@

.PHONY: clean mrproper
@echo suppression de tous les fichiers.

mrproper: clean
@ rm -f $(EXEC)
@echo suppression executable

clean:
@ rm -f *.o
@echo suppression des fichiers objets

Lien vers le commentaire
Partager sur d’autres sites
Soulfly_tribe90 Régulier

Soulfly_tribe90

Posté(e)
  • Auteur
Posté(e)

Je viens de regarder, j'avoue que j'ai pas trop compris comment ca fonctionnait...

Exemple : j'ai un projet qui comporte des dossier bin, headers, src et obj => mon dossier bin va devoir contenir mon executable après compilation, mon dossiers headers contient les entêtes, le dossier src contient mes sources (des .c) et mon dossier obj doit contenir mes fichiers objets généré pendant la compilation séparé (des .o).

Tu ferais comment pour faire ca avec cmake ???

Lien vers le commentaire
Partager sur d’autres sites
jromang Passionné

jromang

Posté(e)
Posté(e)
Ouai c'est une bonne idée effectivement :chinois:

Mais j'aurais bien voulu savoir quand même :francais:

Une petite question pour les gros projet opensource ou il y a des makefile de foufou et des autogen.sh vous croyez qu'ils utilisent ce genre d'outil ??

Oui, ils utilisent les 'Autotools' (autoconf+automake) ; mais beaucoup trouvent ca très compliqué (plusieurs fichiers a remplir, syntaxe différentes) : l'avantage de cmake c'est de tout centraliser dans un unique fichier 'CMakelist.txt' (si tu ne comprends pas ; un exemple simple : http://www.cmake.org/HTML/Examples.html ). Pour ton coup de main sur le Makefile, la mémoire me manque tellement je n'ai plus l'habitude de le faire a la main...désolé :jesquate:

Sinon pour la compilation dans un repertoire séparé c'est 'naturel' avec cmake : ton projet est dans un répertoire précis (disons /home/bob/myProject) et tu appelles cmake depuis un autre repertoire (home/bob/build par exemple) en fesant 'cmake ../myProject' : tous les fichiers intermédiaires sont construits dans 'build', laissant ton projet tout clean

Lien vers le commentaire
Partager sur d’autres sites
  • 1 mois après...
Dams974 Nouveau

Dams974

Posté(e)
Posté(e)

bonjour,

désolé de suivre ton poste un peu tardivement.

Je ne sais pas si une autre reponse t'interesse encore, mais je vais te proposer la mienne quand meme.

Apparament tu avais des soucis d'organisation de ton projet et de ton Makefile à la fois.

La machine doit travailler pr toi, organise toi comme tu veux, fais tes repertoires et

c'est au Makefile de s'adapter a ton projet et à ton organisation.

Si tu mets tes fichiers dans un dossier, il te suffie de dire a ta regle make principale (make all)

d'aller dans les repertoire que tu decide et ensuite seulement de faire ta compilation et ta génération de .o

Ex avec la regle "clean" :

clean : 
		cd src/libctype/ && rm -rf *.o *~ \#*  (on rentre dans le repertoire src/libctype et on execute le le nettoyage)

Sinon tu peux mettre un makefile principal dans le repertoire du projet et un makefile dans le repertoire

de tes sources et appeler le deuxieme Makefile par le premier.

Ex : 

clean : 
		rm -rf *.o *~ \#*  (on nettoie le repertoire principal)
		cd src/libctype/ && make clean  (et on appel le makefile situé dans le repertoire des source pr faire de meme)

Sinon, n'oublie pas si tu veux lier tes .h a tes .c qui ne se trouvent pas dans le meme repertoire de bien preciser ou il se trouve :

Ex :

./include

./include/mm.h

./src

./src/mm.c

./src/mm_extend.c

./src/mm_allocate.c

./src/mm_compare.c

./src/mm_free.c

./src/mm_size.c

./src/mm_options.c

./src/mm_set.c

./src/mm_write.c

./src/mm_read.c

./tests

./Makefile

./configure

--> et tu mets bien dans tes .c : #include "../include/mm.h"

Pour les .o , une fois que tu l'es a créé tu n'as qu'a les déplacer comme ci dessus, par des commandes script : 

.c.o:
	$(CC) -o $@ -c $< $(CFLAGS)
	mv *.o ../obj							 (on deplace les .o dans le repertoire "obj")

Voila, je ne sais pas si ca t'aura aider un peu.

Bonne journée.

Lien vers le commentaire
Partager sur d’autres sites
  • 3 semaines après...
PiFou86 Débutant

PiFou86

Posté(e)
Posté(e)
--> et tu mets bien dans tes .c : #include "../include/mm.h"

Pour les .o , une fois que tu l'es a créé tu n'as qu'a les déplacer comme ci dessus, par des commandes script : 

.c.o:
	$(CC) -o $@ -c $< $(CFLAGS)
	mv *.o ../obj							 (on deplace les .o dans le repertoire "obj")

Pas besoin de mettre #include "../include/mm.h" dans le .c... Il suffit de mettre #include <mm.h> et d'ajouté un -I../include dans la cible .c.o :

.c.o:
	$(CC) -I../include -o $@ -c $< $(CFLAGS)
	mv *.o ../obj							 (on deplace les .o dans le repertoire "obj")

Lien vers le commentaire
Partager sur d’autres sites
  • 1 mois après...
Mephisto Collaborateur

Mephisto

Posté(e)
Posté(e)

les seules fois ou j'ai eu besoin de structurer mon bordel, j'ai fait plusieurs dossiers, et un makefile dans chaque (enfin, un makefile hierarchise quoi)

mon makefile principal ressemble a ca:

NAME	=	mysh

ALIASD	=	./alias/
AUTCMPD	=	./autocmp/
BINDD	=	./bind/
BUFD	=	./buf/
BTD	=	./builtins/
CHECK	=	./checker/
ENVD	=	./env/
ERRD	=	./err/
EXECD	=	./exec/
INITD	=	./init/
JOBD	=	./jobctrl/
LIBD	=	./lib/
LEXD	=	./lexer/
MAIND	=	./main/
PARSD	=	./parser/
QUITD	=	./quit/
SETD	=	./set/
STARD	=	./star/
XD	=	./x/

LDFLAGS	=	-L. -ltermcap #-lefence

RM	=	rm -f

MISC	=	*.o *~ \#*\# *.core

CONF	=	mysh.conf

CC	=	gcc

CFLAGS	=	-g3 -ansi -pedantic -W -Werror -Wall -Wstrict-prototypes

OBJS	=	$(ALIASD)*.o $(AUTCMPD)*.o $(BINDD)*.o $(BUFD)*.o $(BTD)*.o\
	$(CHECK)*.o  $(ENVD)*.o $(ERRD)*.o $(EXECD)*.o $(INITD)*.o\
	$(JOBD)*.o $(LIBD)*.o $(MAIND)*.o $(PARSD)*.o $(QUITD)*.o\
	$(SETD)*.o $(STARD)*.o $(XD)*.o

$(NAME):	do_all
		strip -s $(NAME)
	cp $(NAME) /u/ept1/martin_b/mbim/
	cp $(CONF) /u/ept1/martin_b/mbim/

##################################################
##		BASIC MAKEFILE COMMANDS		##
##################################################

all:		$(NAME)

link:
	$(CC) $(CFLAGS) $(OBJS) $(LDFLAGS) -o $(NAME)

clean:		clean_all
	$(RM) $(OBJS)

fclean:		clean
	$(RM) $(NAME)

re:		fclean all


##################################################
##		ALL GLOBAL COMMANDS		##
##################################################

do_all:		do_alias do_autocmp do_bind do_bt \
	do_buf do_env do_err do_exec do_init \
	do_jobs do_lib do_main do_check\
	do_parse do_quit do_set do_star do_x \
	link

clean_all:	clean_alias clean_autocmp clean_bind \
	clean_bt clean_buf clean_env \
	clean_err clean_exec clean_init \
	clean_jobs clean_lib clean_check \
	clean_main clean_parse clean_quit \
	clean_set clean_star clean_x


##################################################
##		MAKE BASIC COMMANDS		##
##################################################

do_alias:
	@(cd $(ALIASD); make)

do_autocmp:
	@(cd $(AUTCMPD); make)

do_bind:
	@(cd $(BINDD); make)

do_buf:
	@(cd $(BUFD); make)

do_bt:
	@(cd $(BTD); make)

do_check:
	@(cd $(CHECK); make)

do_env:
	@(cd $(ENVD); make)

do_err:
	@(cd $(ERRD); make)

do_exec:
	@(cd $(EXECD); make)

do_init:
	@(cd $(INITD); make)

do_jobs:
	@(cd $(JOBD); make)

do_lib:
	@(cd $(LIBD); make)

do_lexer:
	@(cd $(LEXD); make)

do_main:
	@(cd $(MAIND); make)

do_parse:
	@(cd $(PARSD); make)

do_quit:
	@(cd $(QUITD); make)

do_set:
	@(cd $(SETD); make)

do_star:
	@(cd $(STARD); make)

do_x:
	@(cd $(XD); make)


##################################################
##		MAKE CLEAN COMMANDS		##
##################################################

clean_alias:
	@(cd $(ALIASD); make clean)

clean_autocmp:
	@(cd $(AUTCMPD); make clean)

clean_bind:
	@(cd $(BINDD); make clean)

clean_buf:
	@(cd $(BUFD); make clean)

clean_bt:
	@(cd $(BTD); make clean)

clean_check:
	@(cd $(CHECK); make clean)

clean_env:
	@(cd $(ENVD); make clean)

clean_err:
	@(cd $(ERRD); make clean)

clean_exec:
	@(cd $(EXECD); make clean)

clean_init:
	@(cd $(INITD); make clean)

clean_jobs:
	@(cd $(JOBD); make clean)

clean_lib:
	@(cd $(LIBD); make clean)

clean_lexer:
	@(cd $(LEXD); make clean)

clean_main:
	@(cd $(MAIND); make clean)

clean_parse:
	@(cd $(PARSD); make clean)

clean_quit:
	@(cd $(QUITD); make clean)

clean_set:
	@(cd $(SETD); make clean)

clean_star:
	@(cd $(STARD); make clean)

clean_x:
	@(cd $(XD); make clean)

et un makefile dans un sous-dossier ressemble a ca:

FILES	=	cat.c cd.c clear.c ges.c gl.c helpconf.c history.c \
	isundisplayedbt.c kill.c show.c where.c echo.c

OBJ	=	$(FILES:.c=.o)

CC	=	gcc

CFLAGS	=	-O0 -g3 -W -Wall -Werror -Wstrict-prototypes -Wparentheses -Wunused-function -Wunused-label -Wunused-variable -Wunused-value
#-ansi -pedantic
RM	=	rm -f

MISC	=	*.o *~ \#*\# *.core

all:	$(OBJ)

clean:
$(RM) $(MISC)

bon, c'est vieux, j'avais pas penser a un dossier include qui aurait etait beaucoup plus propre

tu peux reprendre l'idee de PiFou86, -l[folder]

par contre, pour les makefile des sous dossiers, pense au ../ (on sait jamais, hein ^^)

apres, tu peux t'amuser a creer des regles qui ne recompile que certaines parties, rajouter des betises kikoolol, etc.

voilou, amuse toi bien :p

edit: a relire, c'est moche, je l'admet

Lien vers le commentaire
Partager sur d’autres sites

Archivé

Ce sujet est désormais archivé et ne peut plus recevoir de nouvelles réponses.

Aller sur la liste des sujets
×
×
  • Créer...