Je cherche un outil qui me permette de lancer des compilations de façon
simple sur un projet de plusieurs executables.
Quand je dis simple, je veux dire qui sache trouver automatiquement les
dépendances, qui génére les fichiers .o seulement s'ils ne sont pas à jour
avec leurs sources, et qui m'oblige à une certaine organisation de mes
sources évidemment.
Qui fait que je n'ai plus qu'à lancer une compilation de mon executable,
plein d'autres dépendances, de cette façon :
$MON_OUTIL chemin/vers/mon/exe.cpp
Quand je dis simple, je veux dire qui sache trouver automatiquement les dépendances
Un article assez vieux, mais qui te donnera tout de même des pistes : http://freshmeat.net/articles/make-alternatives
James Kanze
On Nov 22, 8:41 pm, TSalm wrote:
Je cherche un outil qui me permette de lancer des compilations de façon simple sur un projet de plusieurs executables.
Quand je dis simple, je veux dire qui sache trouver automatiquement les dépendances, qui génére les fichiers .o seulement s'ils ne son t pas à jour avec leurs sources, et qui m'oblige à une certaine organisation de mes sources évidemment.
Qui fait que je n'ai plus qu'à lancer une compilation de mon executable, plein d'autres dépendances, de cette façon : $MON_OUTIL chemin/vers/mon/exe.cpp
Ca existe ?
Combien d'effort est-ce que tu prêt à investir pour le configurer ? C'est tout à fait possible de faire quelque chose du genre avec GNU make, mais il faut un certain effort dans l'écriture des fichiers de make initiaux. Ensuite, tu crées un alias qui invoque « gmake -f mon_makefile_de_base.mk », et tu invoques l'alias ; gmake saura faire la reste. (C'est plus dans la philosophie des make que tu précises l'exécutable que tu veux construire, plutôt que la source, mais j'ai bien réussi à faire marcher la forme avec la source à l'aide d'un tou t petit peu de shell.)
-- James Kanze
On Nov 22, 8:41 pm, TSalm <ts...@free.fr> wrote:
Je cherche un outil qui me permette de lancer des compilations de
façon simple sur un projet de plusieurs executables.
Quand je dis simple, je veux dire qui sache trouver automatiquement
les dépendances, qui génére les fichiers .o seulement s'ils ne son t
pas à jour avec leurs sources, et qui m'oblige à une certaine
organisation de mes sources évidemment.
Qui fait que je n'ai plus qu'à lancer une compilation de mon
executable, plein d'autres dépendances, de cette façon :
$MON_OUTIL chemin/vers/mon/exe.cpp
Ca existe ?
Combien d'effort est-ce que tu prêt à investir pour le configurer ?
C'est tout à fait possible de faire quelque chose du genre avec GNU
make, mais il faut un certain effort dans l'écriture des fichiers de
make initiaux. Ensuite, tu crées un alias qui invoque « gmake -f
mon_makefile_de_base.mk », et tu invoques l'alias ; gmake saura faire
la
reste. (C'est plus dans la philosophie des make que tu précises
l'exécutable que tu veux construire, plutôt que la source, mais j'ai
bien réussi à faire marcher la forme avec la source à l'aide d'un tou t
petit peu de shell.)
Je cherche un outil qui me permette de lancer des compilations de façon simple sur un projet de plusieurs executables.
Quand je dis simple, je veux dire qui sache trouver automatiquement les dépendances, qui génére les fichiers .o seulement s'ils ne son t pas à jour avec leurs sources, et qui m'oblige à une certaine organisation de mes sources évidemment.
Qui fait que je n'ai plus qu'à lancer une compilation de mon executable, plein d'autres dépendances, de cette façon : $MON_OUTIL chemin/vers/mon/exe.cpp
Ca existe ?
Combien d'effort est-ce que tu prêt à investir pour le configurer ? C'est tout à fait possible de faire quelque chose du genre avec GNU make, mais il faut un certain effort dans l'écriture des fichiers de make initiaux. Ensuite, tu crées un alias qui invoque « gmake -f mon_makefile_de_base.mk », et tu invoques l'alias ; gmake saura faire la reste. (C'est plus dans la philosophie des make que tu précises l'exécutable que tu veux construire, plutôt que la source, mais j'ai bien réussi à faire marcher la forme avec la source à l'aide d'un tou t petit peu de shell.)
-- James Kanze
Fabien LE LEZ
On Mon, 23 Nov 2009 01:14:06 -0800 (PST), James Kanze :
C'est tout à fait possible de faire quelque chose du genre avec GNU make,
Comment fait-on, avec make, pour générer automatiquement les dépendances ? Si je ne m'abuse, make tout seul ne sait pas de quels .h un .cpp dépend.
On Mon, 23 Nov 2009 01:14:06 -0800 (PST), James Kanze
<james.kanze@gmail.com>:
C'est tout à fait possible de faire quelque chose du genre avec GNU
make,
Comment fait-on, avec make, pour générer automatiquement les
dépendances ? Si je ne m'abuse, make tout seul ne sait pas de quels .h
un .cpp dépend.
On Mon, 23 Nov 2009 01:14:06 -0800 (PST), James Kanze :
C'est tout à fait possible de faire quelque chose du genre avec GNU make,
Comment fait-on, avec make, pour générer automatiquement les dépendances ? Si je ne m'abuse, make tout seul ne sait pas de quels .h un .cpp dépend.
Jean-Marc Bourguet
Fabien LE LEZ writes:
On Mon, 23 Nov 2009 01:14:06 -0800 (PST), James Kanze :
>C'est tout à fait possible de faire quelque chose du genre avec GNU >make,
Comment fait-on, avec make, pour générer automatiquement les dépendances ? Si je ne m'abuse, make tout seul ne sait pas de quels .h un .cpp dépend.
Tous les compilateurs que j'utilise ont des flags du genre -M? de GCC, qui permettent de recuperer l'info. Il suffit d'inclure le resultat dans le Makefile (ce qui suppose un make qui permet l'inclusion sans erreur si le fichier n'existe pas, comme GNU make).
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Fabien LE LEZ <gramster@gramster.com> writes:
On Mon, 23 Nov 2009 01:14:06 -0800 (PST), James Kanze
<james.kanze@gmail.com>:
>C'est tout à fait possible de faire quelque chose du genre avec GNU
>make,
Comment fait-on, avec make, pour générer automatiquement les
dépendances ? Si je ne m'abuse, make tout seul ne sait pas de quels .h
un .cpp dépend.
Tous les compilateurs que j'utilise ont des flags du genre -M? de GCC, qui
permettent de recuperer l'info. Il suffit d'inclure le resultat dans le
Makefile (ce qui suppose un make qui permet l'inclusion sans erreur si le
fichier n'existe pas, comme GNU make).
A+
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
On Mon, 23 Nov 2009 01:14:06 -0800 (PST), James Kanze :
>C'est tout à fait possible de faire quelque chose du genre avec GNU >make,
Comment fait-on, avec make, pour générer automatiquement les dépendances ? Si je ne m'abuse, make tout seul ne sait pas de quels .h un .cpp dépend.
Tous les compilateurs que j'utilise ont des flags du genre -M? de GCC, qui permettent de recuperer l'info. Il suffit d'inclure le resultat dans le Makefile (ce qui suppose un make qui permet l'inclusion sans erreur si le fichier n'existe pas, comme GNU make).
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Richard Delorme
Le 23/11/2009 12:58, Fabien LE LEZ a écrit :
On Mon, 23 Nov 2009 01:14:06 -0800 (PST), James Kanze :
C'est tout à fait possible de faire quelque chose du genre avec GNU make,
Comment fait-on, avec make, pour générer automatiquement les dépendances ? Si je ne m'abuse, make tout seul ne sait pas de quels .h un .cpp dépend.
Non, en effet. Il faut utiliser l'option -MM du préprocesseur de gcc. Mais c'est facile d'inclure la commande dans le Makefile :
Le 23/11/2009 12:58, Fabien LE LEZ a écrit : > On Mon, 23 Nov 2009 01:14:06 -0800 (PST), James Kanze > : > >> C'est tout à fait possible de faire quelque chose du genre avec GNU >> make, > > Comment fait-on, avec make, pour générer automatiquement les > dépendances ? Si je ne m'abuse, make tout seul ne sait pas de quels .h > un .cpp dépend.
Non, en effet. Il faut utiliser l'option -MM du préprocesseur de gcc. Mais c'est facile d'inclure la commande dans le Makefile :
Je refais automatiquement la dependance avec l'objet. Ca evite de devoir se poser des questions quand a la necessite de faire un make depend. Donc pour gcc
CXXFLAGS=-MMD -include $(OBJECTS:.o=.d)
pour les compilateurs sans equivalent de -MMD, c'est
(La seule chose a laquelle il faut faire attention, c'est introduire explicitement les dependances sur les fichiers generes pour eviter que la compil d'un fichier foire parce qu'un fichier genere n'est pas fait).
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Richard Delorme <abulmo@nospam.fr> writes:
Le 23/11/2009 12:58, Fabien LE LEZ a écrit :
> On Mon, 23 Nov 2009 01:14:06 -0800 (PST), James Kanze
> <james.kanze@gmail.com>:
>
>> C'est tout à fait possible de faire quelque chose du genre avec GNU
>> make,
>
> Comment fait-on, avec make, pour générer automatiquement les
> dépendances ? Si je ne m'abuse, make tout seul ne sait pas de quels .h
> un .cpp dépend.
Non, en effet. Il faut utiliser l'option -MM du préprocesseur de gcc. Mais
c'est facile d'inclure la commande dans le Makefile :
Je refais automatiquement la dependance avec l'objet. Ca evite de devoir
se poser des questions quand a la necessite de faire un make depend. Donc
pour gcc
CXXFLAGS=-MMD
-include $(OBJECTS:.o=.d)
pour les compilateurs sans equivalent de -MMD, c'est
(La seule chose a laquelle il faut faire attention, c'est introduire
explicitement les dependances sur les fichiers generes pour eviter que la
compil d'un fichier foire parce qu'un fichier genere n'est pas fait).
A+
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
Le 23/11/2009 12:58, Fabien LE LEZ a écrit : > On Mon, 23 Nov 2009 01:14:06 -0800 (PST), James Kanze > : > >> C'est tout à fait possible de faire quelque chose du genre avec GNU >> make, > > Comment fait-on, avec make, pour générer automatiquement les > dépendances ? Si je ne m'abuse, make tout seul ne sait pas de quels .h > un .cpp dépend.
Non, en effet. Il faut utiliser l'option -MM du préprocesseur de gcc. Mais c'est facile d'inclure la commande dans le Makefile :
Je refais automatiquement la dependance avec l'objet. Ca evite de devoir se poser des questions quand a la necessite de faire un make depend. Donc pour gcc
CXXFLAGS=-MMD -include $(OBJECTS:.o=.d)
pour les compilateurs sans equivalent de -MMD, c'est
(La seule chose a laquelle il faut faire attention, c'est introduire explicitement les dependances sur les fichiers generes pour eviter que la compil d'un fichier foire parce qu'un fichier genere n'est pas fait).
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
espie
In article , Jean-Marc Bourguet wrote:
Fabien LE LEZ writes:
On Mon, 23 Nov 2009 01:14:06 -0800 (PST), James Kanze :
>C'est tout à fait possible de faire quelque chose du genre avec GNU >make,
Comment fait-on, avec make, pour générer automatiquement les dépendances ? Si je ne m'abuse, make tout seul ne sait pas de quels .h un .cpp dépend.
Tous les compilateurs que j'utilise ont des flags du genre -M? de GCC, qui permettent de recuperer l'info. Il suffit d'inclure le resultat dans le Makefile (ce qui suppose un make qui permet l'inclusion sans erreur si le fichier n'existe pas, comme GNU make).
Mais t'as toujours un petit probleme cote info-a-jour: faut faire tourner gcc -M pour fabriquer le fichier en question, ce qui se fait avec un bout de makefile. Mais une fois que ca a change, ben faut relancer make... avec les bonnes dependances.
C'est une des multiples limitations de make, gnu-make n'etant pas mieux que les autres (etant plutot pire cote documentation qui oublie de dire ce qui est specifique a gnu-make, et ce qui est standard).
Il y a quelques tentatives de ci, de la, pour faire mieux, mais rien de vraiment concluant dans mon experience...
In article <pxbtywlbgav.fsf@news.bourguet.org>,
Jean-Marc Bourguet <jm@bourguet.org> wrote:
Fabien LE LEZ <gramster@gramster.com> writes:
On Mon, 23 Nov 2009 01:14:06 -0800 (PST), James Kanze
<james.kanze@gmail.com>:
>C'est tout à fait possible de faire quelque chose du genre avec GNU
>make,
Comment fait-on, avec make, pour générer automatiquement les
dépendances ? Si je ne m'abuse, make tout seul ne sait pas de quels .h
un .cpp dépend.
Tous les compilateurs que j'utilise ont des flags du genre -M? de GCC, qui
permettent de recuperer l'info. Il suffit d'inclure le resultat dans le
Makefile (ce qui suppose un make qui permet l'inclusion sans erreur si le
fichier n'existe pas, comme GNU make).
Mais t'as toujours un petit probleme cote info-a-jour: faut faire tourner
gcc -M pour fabriquer le fichier en question, ce qui se fait avec un bout
de makefile. Mais une fois que ca a change, ben faut relancer make... avec
les bonnes dependances.
C'est une des multiples limitations de make, gnu-make n'etant pas mieux que
les autres (etant plutot pire cote documentation qui oublie de dire ce qui
est specifique a gnu-make, et ce qui est standard).
Il y a quelques tentatives de ci, de la, pour faire mieux, mais rien de
vraiment concluant dans mon experience...
On Mon, 23 Nov 2009 01:14:06 -0800 (PST), James Kanze :
>C'est tout à fait possible de faire quelque chose du genre avec GNU >make,
Comment fait-on, avec make, pour générer automatiquement les dépendances ? Si je ne m'abuse, make tout seul ne sait pas de quels .h un .cpp dépend.
Tous les compilateurs que j'utilise ont des flags du genre -M? de GCC, qui permettent de recuperer l'info. Il suffit d'inclure le resultat dans le Makefile (ce qui suppose un make qui permet l'inclusion sans erreur si le fichier n'existe pas, comme GNU make).
Mais t'as toujours un petit probleme cote info-a-jour: faut faire tourner gcc -M pour fabriquer le fichier en question, ce qui se fait avec un bout de makefile. Mais une fois que ca a change, ben faut relancer make... avec les bonnes dependances.
C'est une des multiples limitations de make, gnu-make n'etant pas mieux que les autres (etant plutot pire cote documentation qui oublie de dire ce qui est specifique a gnu-make, et ce qui est standard).
Il y a quelques tentatives de ci, de la, pour faire mieux, mais rien de vraiment concluant dans mon experience...
Jean-Marc Bourguet
(Marc Espie) writes:
Mais t'as toujours un petit probleme cote info-a-jour: faut faire tourner gcc -M pour fabriquer le fichier en question, ce qui se fait avec un bout de makefile. Mais une fois que ca a change, ben faut relancer make... avec les bonnes dependances.
Si je ne me trompe pas, les dependances sont invalidees exactement dans les memes circonstances que le fichier objet -- du moins tant qu'on s'en tient a la logique de make de se baser sur les dates.
C'est une des multiples limitations de make, gnu-make n'etant pas mieux que les autres (etant plutot pire cote documentation qui oublie de dire ce qui est specifique a gnu-make, et ce qui est standard).
Il y a quelques tentatives de ci, de la, pour faire mieux, mais rien de vraiment concluant dans mon experience...
clearmake (mais avec tous les avantages et les inconveniants de clearcase) tant qu'on n'a pas de fichier qui peuvent etre mis a jour correctement de plusieurs manieres (la gestion historique des templates de Sun CC par exemple posait probleme).
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
espie@lain.home (Marc Espie) writes:
Mais t'as toujours un petit probleme cote info-a-jour: faut faire tourner
gcc -M pour fabriquer le fichier en question, ce qui se fait avec un bout
de makefile. Mais une fois que ca a change, ben faut relancer make... avec
les bonnes dependances.
Si je ne me trompe pas, les dependances sont invalidees exactement dans les
memes circonstances que le fichier objet -- du moins tant qu'on s'en tient
a la logique de make de se baser sur les dates.
C'est une des multiples limitations de make, gnu-make n'etant pas mieux que
les autres (etant plutot pire cote documentation qui oublie de dire ce qui
est specifique a gnu-make, et ce qui est standard).
Il y a quelques tentatives de ci, de la, pour faire mieux, mais rien de
vraiment concluant dans mon experience...
clearmake (mais avec tous les avantages et les inconveniants de clearcase)
tant qu'on n'a pas de fichier qui peuvent etre mis a jour correctement de
plusieurs manieres (la gestion historique des templates de Sun CC par
exemple posait probleme).
A+
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
Mais t'as toujours un petit probleme cote info-a-jour: faut faire tourner gcc -M pour fabriquer le fichier en question, ce qui se fait avec un bout de makefile. Mais une fois que ca a change, ben faut relancer make... avec les bonnes dependances.
Si je ne me trompe pas, les dependances sont invalidees exactement dans les memes circonstances que le fichier objet -- du moins tant qu'on s'en tient a la logique de make de se baser sur les dates.
C'est une des multiples limitations de make, gnu-make n'etant pas mieux que les autres (etant plutot pire cote documentation qui oublie de dire ce qui est specifique a gnu-make, et ce qui est standard).
Il y a quelques tentatives de ci, de la, pour faire mieux, mais rien de vraiment concluant dans mon experience...
clearmake (mais avec tous les avantages et les inconveniants de clearcase) tant qu'on n'a pas de fichier qui peuvent etre mis a jour correctement de plusieurs manieres (la gestion historique des templates de Sun CC par exemple posait probleme).
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
espie
In article , Jean-Marc Bourguet wrote:
(Marc Espie) writes:
Mais t'as toujours un petit probleme cote info-a-jour: faut faire tourner gcc -M pour fabriquer le fichier en question, ce qui se fait avec un bout de makefile. Mais une fois que ca a change, ben faut relancer make... avec les bonnes dependances.
Si je ne me trompe pas, les dependances sont invalidees exactement dans les memes circonstances que le fichier objet -- du moins tant qu'on s'en tient a la logique de make de se baser sur les dates.
C'est une des multiples limitations de make, gnu-make n'etant pas mieux que les autres (etant plutot pire cote documentation qui oublie de dire ce qui est specifique a gnu-make, et ce qui est standard).
Il y a quelques tentatives de ci, de la, pour faire mieux, mais rien de vraiment concluant dans mon experience...
clearmake (mais avec tous les avantages et les inconveniants de clearcase) tant qu'on n'a pas de fichier qui peuvent etre mis a jour correctement de plusieurs manieres (la gestion historique des templates de Sun CC par exemple posait probleme).
Revenons quand meme a la question de depart: le posteur initial voulait un truc simple, et qui marche... de quelque facon qu'on y regarde, make ne remplit pas ce cahier des charges. Deja, c'est pas tres simple, surtout pour du C++, mais surtout, si ca reste simple, ca ne marche pas (bien), et si ca ne reste pas simple, ca ne marche quand meme pas parfaitement...
In article <pxbiqd1b8ec.fsf@news.bourguet.org>,
Jean-Marc Bourguet <jm@bourguet.org> wrote:
espie@lain.home (Marc Espie) writes:
Mais t'as toujours un petit probleme cote info-a-jour: faut faire tourner
gcc -M pour fabriquer le fichier en question, ce qui se fait avec un bout
de makefile. Mais une fois que ca a change, ben faut relancer make... avec
les bonnes dependances.
Si je ne me trompe pas, les dependances sont invalidees exactement dans les
memes circonstances que le fichier objet -- du moins tant qu'on s'en tient
a la logique de make de se baser sur les dates.
C'est une des multiples limitations de make, gnu-make n'etant pas mieux que
les autres (etant plutot pire cote documentation qui oublie de dire ce qui
est specifique a gnu-make, et ce qui est standard).
Il y a quelques tentatives de ci, de la, pour faire mieux, mais rien de
vraiment concluant dans mon experience...
clearmake (mais avec tous les avantages et les inconveniants de clearcase)
tant qu'on n'a pas de fichier qui peuvent etre mis a jour correctement de
plusieurs manieres (la gestion historique des templates de Sun CC par
exemple posait probleme).
Revenons quand meme a la question de depart: le posteur initial voulait un truc
simple, et qui marche... de quelque facon qu'on y regarde, make ne remplit
pas ce cahier des charges. Deja, c'est pas tres simple, surtout pour du C++,
mais surtout, si ca reste simple, ca ne marche pas (bien), et si ca ne reste
pas simple, ca ne marche quand meme pas parfaitement...
Mais t'as toujours un petit probleme cote info-a-jour: faut faire tourner gcc -M pour fabriquer le fichier en question, ce qui se fait avec un bout de makefile. Mais une fois que ca a change, ben faut relancer make... avec les bonnes dependances.
Si je ne me trompe pas, les dependances sont invalidees exactement dans les memes circonstances que le fichier objet -- du moins tant qu'on s'en tient a la logique de make de se baser sur les dates.
C'est une des multiples limitations de make, gnu-make n'etant pas mieux que les autres (etant plutot pire cote documentation qui oublie de dire ce qui est specifique a gnu-make, et ce qui est standard).
Il y a quelques tentatives de ci, de la, pour faire mieux, mais rien de vraiment concluant dans mon experience...
clearmake (mais avec tous les avantages et les inconveniants de clearcase) tant qu'on n'a pas de fichier qui peuvent etre mis a jour correctement de plusieurs manieres (la gestion historique des templates de Sun CC par exemple posait probleme).
Revenons quand meme a la question de depart: le posteur initial voulait un truc simple, et qui marche... de quelque facon qu'on y regarde, make ne remplit pas ce cahier des charges. Deja, c'est pas tres simple, surtout pour du C++, mais surtout, si ca reste simple, ca ne marche pas (bien), et si ca ne reste pas simple, ca ne marche quand meme pas parfaitement...
TSalm
Le Mon, 23 Nov 2009 16:30:40 +0100, Marc Espie a écrit:
In article , Jean-Marc Bourguet wrote:
(Marc Espie) writes:
Mais t'as toujours un petit probleme cote info-a-jour: faut faire tourner gcc -M pour fabriquer le fichier en question, ce qui se fait avec un bout de makefile. Mais une fois que ca a change, ben faut relancer make... avec les bonnes dependances.
Si je ne me trompe pas, les dependances sont invalidees exactement dans les memes circonstances que le fichier objet -- du moins tant qu'on s'en tient a la logique de make de se baser sur les dates.
C'est une des multiples limitations de make, gnu-make n'etant pas mieux que les autres (etant plutot pire cote documentation qui oublie de dire ce qui est specifique a gnu-make, et ce qui est standard).
Il y a quelques tentatives de ci, de la, pour faire mieux, mais rien de vraiment concluant dans mon experience...
clearmake (mais avec tous les avantages et les inconveniants de clearcase) tant qu'on n'a pas de fichier qui peuvent etre mis a jour correctement de plusieurs manieres (la gestion historique des templates de Sun CC par exemple posait probleme).
Revenons quand meme a la question de depart: le posteur initial voulait un truc simple, et qui marche... de quelque facon qu'on y regarde, make ne remplit pas ce cahier des charges. Deja, c'est pas tres simple, surtout pour du C++, mais surtout, si ca reste simple, ca ne marche pas (bien), et si ca ne reste pas simple, ca ne marche quand meme pas parfaitement...
Si tu entends par "ça ne marche pas bien", que ça oblige à avoir une façon d'organiser ses sources qui soit restreinte, ça m'irait parfaitement bien.
Concernant mon organisation, c'est celle d'un débutant que je suis, et qui me convient pas mal jusqu'ici : - j'ai une racine, appelont la src/ - quand je fait un include avec des doubles-quotes (#include "doss1/doss2/mon_fichier.hpp"), il est dans "src/doss1/doss2/" - si le fichier .hpp dont mon executable dépends a un .cpp (même nom), alors il faut générer ce .o et l'inclure lors du "linkage" de l'executable - sur chaque executable à générer, on peut individuellement passer des paramètres de compilation. Ceci pour indiquer où chercher les entêtes et les librairies statiques.
Ca n'existe pas ce genre du truc? C'est plus compliqué que je le crois ?
Le Mon, 23 Nov 2009 16:30:40 +0100, Marc Espie <espie@lain.home> a écrit:
In article <pxbiqd1b8ec.fsf@news.bourguet.org>,
Jean-Marc Bourguet <jm@bourguet.org> wrote:
espie@lain.home (Marc Espie) writes:
Mais t'as toujours un petit probleme cote info-a-jour: faut faire
tourner
gcc -M pour fabriquer le fichier en question, ce qui se fait avec un
bout
de makefile. Mais une fois que ca a change, ben faut relancer make...
avec
les bonnes dependances.
Si je ne me trompe pas, les dependances sont invalidees exactement dans
les
memes circonstances que le fichier objet -- du moins tant qu'on s'en
tient
a la logique de make de se baser sur les dates.
C'est une des multiples limitations de make, gnu-make n'etant pas
mieux que
les autres (etant plutot pire cote documentation qui oublie de dire ce
qui
est specifique a gnu-make, et ce qui est standard).
Il y a quelques tentatives de ci, de la, pour faire mieux, mais rien de
vraiment concluant dans mon experience...
clearmake (mais avec tous les avantages et les inconveniants de
clearcase)
tant qu'on n'a pas de fichier qui peuvent etre mis a jour correctement
de
plusieurs manieres (la gestion historique des templates de Sun CC par
exemple posait probleme).
Revenons quand meme a la question de depart: le posteur initial voulait
un truc
simple, et qui marche... de quelque facon qu'on y regarde, make ne
remplit
pas ce cahier des charges. Deja, c'est pas tres simple, surtout pour du
C++,
mais surtout, si ca reste simple, ca ne marche pas (bien), et si ca ne
reste
pas simple, ca ne marche quand meme pas parfaitement...
Si tu entends par "ça ne marche pas bien", que ça oblige à avoir une façon
d'organiser ses sources qui soit restreinte, ça m'irait parfaitement bien.
Concernant mon organisation, c'est celle d'un débutant que je suis, et qui
me convient pas mal jusqu'ici :
- j'ai une racine, appelont la src/
- quand je fait un include avec des doubles-quotes (#include
"doss1/doss2/mon_fichier.hpp"), il est dans "src/doss1/doss2/"
- si le fichier .hpp dont mon executable dépends a un .cpp (même nom),
alors il faut générer ce .o et l'inclure lors du "linkage" de l'executable
- sur chaque executable à générer, on peut individuellement passer des
paramètres de compilation. Ceci pour indiquer où chercher les entêtes et
les librairies statiques.
Ca n'existe pas ce genre du truc? C'est plus compliqué que je le crois ?
Le Mon, 23 Nov 2009 16:30:40 +0100, Marc Espie a écrit:
In article , Jean-Marc Bourguet wrote:
(Marc Espie) writes:
Mais t'as toujours un petit probleme cote info-a-jour: faut faire tourner gcc -M pour fabriquer le fichier en question, ce qui se fait avec un bout de makefile. Mais une fois que ca a change, ben faut relancer make... avec les bonnes dependances.
Si je ne me trompe pas, les dependances sont invalidees exactement dans les memes circonstances que le fichier objet -- du moins tant qu'on s'en tient a la logique de make de se baser sur les dates.
C'est une des multiples limitations de make, gnu-make n'etant pas mieux que les autres (etant plutot pire cote documentation qui oublie de dire ce qui est specifique a gnu-make, et ce qui est standard).
Il y a quelques tentatives de ci, de la, pour faire mieux, mais rien de vraiment concluant dans mon experience...
clearmake (mais avec tous les avantages et les inconveniants de clearcase) tant qu'on n'a pas de fichier qui peuvent etre mis a jour correctement de plusieurs manieres (la gestion historique des templates de Sun CC par exemple posait probleme).
Revenons quand meme a la question de depart: le posteur initial voulait un truc simple, et qui marche... de quelque facon qu'on y regarde, make ne remplit pas ce cahier des charges. Deja, c'est pas tres simple, surtout pour du C++, mais surtout, si ca reste simple, ca ne marche pas (bien), et si ca ne reste pas simple, ca ne marche quand meme pas parfaitement...
Si tu entends par "ça ne marche pas bien", que ça oblige à avoir une façon d'organiser ses sources qui soit restreinte, ça m'irait parfaitement bien.
Concernant mon organisation, c'est celle d'un débutant que je suis, et qui me convient pas mal jusqu'ici : - j'ai une racine, appelont la src/ - quand je fait un include avec des doubles-quotes (#include "doss1/doss2/mon_fichier.hpp"), il est dans "src/doss1/doss2/" - si le fichier .hpp dont mon executable dépends a un .cpp (même nom), alors il faut générer ce .o et l'inclure lors du "linkage" de l'executable - sur chaque executable à générer, on peut individuellement passer des paramètres de compilation. Ceci pour indiquer où chercher les entêtes et les librairies statiques.
Ca n'existe pas ce genre du truc? C'est plus compliqué que je le crois ?
