Itération sur les listes dans les fichiers Makefile?

Je trouve que je suis en train d'écrire beaucoup de Makefiles qui pourraient être nettoyé avec l'utilisation de n-tuple de listes. Mais je ne trouve pas de façon de le faire correctement (et proprement). Jusqu'à présent, j'ai seulement été en mesure de venir avec l'aide $(shell ...) et tr, sed, ou autrement non Makefile normes.

Par exemple, j'aimerais faire ceci:

XYZs = \
    dog.c  pull_tail bark  \
    duck.c chase     quack \
    cow.c  tip       moo

all:
    @- $(foreach X Y Z,$(XYZs), \
        $(CC) $X -o bully/$Y ; \
        ln bully/$Y sounds/$Z ; \
    )

Est-il un bon moyen pour parcourir n-tuple de listes dans les fichiers Makefile? Merci!

OriginalL'auteur Dylan | 2009-06-10

  1. 11

    Les Makefiles sont essentiellement déclarative dans la nature, donc je ne pense pas que faire de lui-même fournit ce que vous voulez. Cependant, vous semblez vouloir associer des valeurs de chaîne avec des objectifs précis, peut-être que l' Cible spécifique les valeurs de la variable fonction de GNU make. Ceci est un extrait de la notice:

    Il y a encore une particularité de
    l'objectif spécifique de variables: lorsque vous
    définir un objectif spécifique de la variable,
    que la valeur de la variable est également en vigueur
    pour toutes les dépendances de cette cible
    (à moins que ces dépendances de la remplacer
    avec leurs propres spécifiques à la cible
    valeur de la variable). Ainsi, par exemple, un
    déclaration comme ceci:

    prog : CFLAGS = -g

    prog : prog.o foo.o bar.o

    sera mis CFLAGS à -g dans la commande
    script pour prog, mais il sera également
    ensemble CFLAGS à -g dans la commande
    des scripts permettant de créer prog.o foo.o,
    et d'un bar.o, et toutes les scripts de commandes
    qui créent leurs dépendances.

    Si vous ne l'avez pas déjà lu, le GNU make manuel est assez bien fichu.

    Edit: De faire ce que vous m'avez demandé dans votre commentaire:

    dog: ANIMAL=dog.c BULLY=pull_tail SOUND=bark

    utilisation:

    dog: ANIMAL=dog.c 
dog: BULLY=pull_tail 
dog: SOUND=bark
    Cool, et il pourrait être à mi-chemin là! Est-il la syntaxe pour ce faire? chien: ANIMAL=chien.c BULLY=pull_tail SON=écorce
    +1, très agréable.
    Le problème n'est pas que faire est déclaratif, c'est qu'il ne fournit pas une syntaxe déclarative pour cette fréquemment modèle!

    OriginalL'auteur

  2. 7

    Je voudrais vérifier le GNU Make manuel sur foreach. voici quelques aléatoire cisailles que j'ai utilisé dans un autre projet... l'exemple est incomplet, mais peut-être que ça vous donnera quelques idées? Je pourrais nettoyer cette plus tard si j'ai plus de temps...

    REMAKE_PROGS:= dog duck cow

XYZs = \
    dog.c  pull_tail bark  \
    duck.c chase     quack \
    cow.c  tip       moo

$(foreach src, $(XYZs), $(eval $MAKE $(src))

$(REMAKE_PROGS):
        @echo "\n# === $@ linking\n"
        $(call compile,$@,$(OBJS_$@),$(CXX),$(MPICXX),$(LDFLAGS) $(LIBS) $(SYSLIBS) $(OTHER_LIB) $(EXTRA_LD_FLAGS))
        @echo "\n# --- $@ compiled\n"

define compile
  @mkdir -p $(dir $(1))
  $(if ${ANNOUNCE},@echo "\n# +++ ${MAKECMDGOALS} compiling\n" $(eval ANNOUNCE=))
  $(call compiler,$(1),NOMPI,$(3),$(4))
  $(eval MY_FLAGS=$(FLAGS_$(1)) $(5))
  $(if $(filter %xlf %xlf90,$(COMPILER_$(1))),$(eval MY_FLAGS:=$(MY_FLAGS:-D%=-WF,-D%)))
  $(strip $(COMPILER_$(1)) $(2) $(MY_FLAGS) -o $(1) )
endef
    Je suis aide pas foreach-appel-faire, mais foreach-eval appel, ce qui est tout aussi moche. Voir gnu.org/software/automake/manual/make/...

    OriginalL'auteur Pete

  3. 6

    Merci pour les conseils -- après quelques de piratage je pense que c'est ce que j'espérais:

    XYZs = \
    dog.c:pull_tail:bark  \
    duck.c:chase:quack \
    cow.c:tip:moo

all:
    @- $(foreach XYZ,$(XYZs), \
        $(eval X = $(word 1,$(subst :, ,$(XYZ)))) \
        $(eval Y = $(word 2,$(subst :, ,$(XYZ)))) \
        $(eval Z = $(word 3,$(subst :, ,$(XYZ)))) \
        \
        $(CC) $X -o bully/$Y ; \
        ln bully/$Y sounds/$Z ; \
    )

    Quelqu'un peut-il faire mieux?

    OriginalL'auteur Dylan

  4. 2

    Aucun de ceux que je connais, mais c'est parce que vous essayez de force de faire de travail et un langage impératif, quand ce n'est pas ce qu'il est.

    Dans GNU make, vous voudrez probablement faire quelque chose comme:

    pull_tail : SOUND=bark
pull_tail : dog.c 
        $(CC) $< -o $^
        ln $@ $(SOUND)

chase : SOUND=quack
chase : duck.c 
        $(CC) $< -o $^
        ln $@ $(SOUND)

...

    Ou, mieux encore, de redéfinir la règle par défaut .c fichiers pour gérer les liens pour vous, mais l'étrange structure de vos noms (les noms de programme n'ont pas une relation lexicale à la source des noms) rend difficile.

    Si ce que vous voulez être en mesure de reconstruire rapidement sans beaucoup de main d'édition, vous pouvez écrire un script pour régénérer le fichier makefile framgment de données et l'utilisation de la include fonction de GNU make...

    OriginalL'auteur dmckee

  5. 0

    Vous êtes en train de faire à l'envers.

    Vous êtes à essayer de les traiter comme c'est un script. Ce n'est pas, à la place c'est un ensemble de règles sur la façon de créer X donné Y. Puis le faire moteur chiffres ce qui doit arriver à obtenir ce résultat.

    Pour l'exemple donné, vous devez vraiment être à l'aide d'un script pour la génération qui suit. Peut-être l'appel que de faire, mais laisser faire la poignée de la CC des trucs.

    C'est une limitation de faire qui n'a aucune raison d'être là, en premier lieu, et peut être contourné avec $(foreach) de toute façon.

    OriginalL'auteur caskey

  6. 0

    Vous pouvez utiliser des règles par défaut pour un ensemble de fichiers avec la même extension que pour la compilation de chaque c fichier à un o. Bien sûr, vous n'êtes pas limité à aucune des extensions de fichier. Pour la compilation d'un ensemble de .c fichiers que vous pourriez faire comme ceci:

    OBJS = foo.o bar.o baz.o
OUT = myprog

all: $(OBJS)
        $(SILENT) echo "LD $@"
        $(SILENT) $(CPP) -o $(OUT) $^ $(LDFLAGS)

%.o: %.c
        $(SILENT) echo "CC $<"
        $(SILENT) $(CC) $(CCOPTS) -o $@ -c $<
    Le problème commence quand vous avez besoin d'utiliser un "courant de $(OBJ) la valeur" dans le modèle de la règle. GNU make n'est pas fournir une syntaxe déclarative, et $(foreach) est un vilain (mais parfaitement fonctionnel) solution de contournement.

    OriginalL'auteur bluebrother