En passant des variables supplémentaires en ligne de commande pour faire

Puis-je passer des variables à une GNU Makefile comme arguments de ligne de commande? En d'autres termes, je veux passer quelques arguments qui deviendra par la suite les variables dans le fichier Makefile.

InformationsquelleAutor Pablo | 2010-05-13

650

Vous disposez de plusieurs options pour définir des variables à partir de l'extérieur de votre makefile:
- De l'environnement - chaque variable d'environnement est transformé en un makefile variable avec le même nom et la valeur.
  
  Vous pouvez également définir -e option (aka --environments-override), et vos variables d'environnement remplacent les cessions effectuées dans le makefile (à moins que ces travaux utilisent eux-mêmes le remplacer de la directive . Cependant, il n'est pas recommandé, et c'est beaucoup mieux et beaucoup plus souple à utiliser ?= affectation (la variable de condition opérateur d'affectation, il n'a d'effet que si la variable n'est pas encore défini):
```
FOO?=default_value_if_not_set_in_environment
```
  Noter que certaines variables ne sont pas héritées de l'environnement:
  - MAKE est obtenu à partir du nom du script
  - SHELL est définie dans un fichier makefile, ou par défaut à /bin/sh (justification: les commandes sont spécifiées dans le fichier makefile, et ils sont shell-spécifique).
- En ligne de commande - make peut prendre des assignations de variables dans le cadre de sa ligne de commande, mêlé avec des cibles:
```
make target FOO=bar
```
  Mais alors toutes les missions à FOO variable dans le fichier makefile sera ignorée sauf si vous utilisez le remplacer de la directive dans la tâche. (L'effet est le même qu'avec -e option pour les variables d'environnement).
- L'exportation à partir de la parent de Faire - si vous appelez Faire à partir d'un Makefile, généralement, vous ne devriez pas écrire explicitement des affectations de variables comme ceci:
```
# Don't do this!
target:
        $(MAKE) -C target CC=$(CC) CFLAGS=$(CFLAGS)
```
  Au lieu de cela, la meilleure solution pourrait être de l'exportation de ces variables. L'exportation d'une variable dans l'environnement de chaque coquille d'invocation, et de Faire des appels à partir de ces commandes de sélection de ces variable d'environnement comme indiqué ci-dessus.
```
# Do like this
CFLAGS=-g
export CFLAGS
target:
        $(MAKE) -C target
```
  Vous pouvez également exporter tous variables en utilisant export sans arguments.
- pour passer de la ligne de commande quelque chose avec des espaces ne make A='"as df"'
- Semble que vous êtes d'avoir des ennuis si vous vous souciez de variables d'environnement. Pour une chose, c'est un débogage cauchemar si elle fonctionne bien en place et pas à la place de B, juste parce qu'ils ont des environnements différents.
- Effectivement, il est orthographié --environnement-remplace
- Juste, fondée sur l'expérience, l'exportation des trucs comme CFLAGS est une recette pour un cauchemar pour les grands projets. De grands projets ont souvent de la 3e partie des bibliothèques de compilation uniquement avec un ensemble donné de drapeaux (que personne ne se soucie de fixation). Si vous exportez la variable CFLAGS, votre projet CFLAGS finit par substitution de la 3e partie de la bibliothèque et déclenche des erreurs de compilation. Une autre voie pourrait être de définir export PROJECT_MAKE_ARGS = CC=$(CC) CFLAGS=$(CFLAGS) et de le passer comme make -C folder $(PROJECT_MAKE_FLAGS). Si il y a un moyen de dire à la bibliothèque du makefile pour ignorer l'environnement, ce serait l'idéal (en face de l'-e).
- Pour passer des variables à une submake, envisager l'ajout de MAKEFLAGS dans le parent de faire. Voir ici.
- AVERTISSEMENT: Dans la section "Exportation de la part du parent à Faire de la" ci-dessus, "ne fais pas cela!" est critique trompeuse. Passer des variables sur la ligne de commande remplace les attributions de la sous-makefile mais exporté variables ne pas remplacer les attributions de la sous-makefile. Ces deux méthodes pour passer des variables à une sous-makefile sont pas équivalent et ne doivent pas être confondus.
- Les gars quelqu'un a du succès à l'aide de faire override déclaration? Parce que je viens d'obtenir: make: override: Command not found
- J'aimerais savoir pourquoi cela ne fonctionne pas; j'ai un fichier "makefile" qui a ifdef($(DEBUG),1) debug_flags else normal_flags endif qui est situé dans la partie supérieure et la variable est passée en ligne de commande comme make all DEBUG=1 ou make DEBUG=1 all mais il ignore la valeur et utilise la valeur définie par DEBUG ?= 0 à tout moment. Pourquoi est-ce?
- Juste pour compléter, c'est la lien la documentation de la en ligne De commande approche.
- Plusieurs arguments?
- Une différence ? make target FOO=bar make FOO=bar target ?
InformationsquelleAutor P Shved
174

La façon la plus simple est:
```
make foo=bar target
```
Ensuite dans votre makefile, vous pouvez vous référer à $(foo). Notez que cela ne se propagent pas à sous-rend automatiquement.

Si vous utilisez des sous-marques, voir cet article: La communication des Variables à un Sous-rendre
- par sous-rend-vous dire aux makefiles included dans le makefile principal?
- Cela signifie faire appel à nouveau à partir de l'intérieur du makefile. J'ai mis à jour ma réponse puisque vous semblez intéressé par ce détail.
- "Notez que cela ne se propagent pas à sous-rend automatiquement." Faux! "Par défaut, seules les variables qui venaient de l'environnement ou de la ligne de commande sont transmis à récursive des invocations. Vous pouvez utiliser la directive d'exportation pour passer à d'autres variables." gnu.org/software/make/manual/html_node/...
InformationsquelleAutor Mark Byers
61

Dire que vous avez un fichier makefile comme ceci:
```
action:
    echo argument is $(argument)
```
Vous serait alors de l'appeler make action argument=something
- aussi, la cible et les arguments peuvent être échangés en termes de position?
- Oui (voir la réponse de la Marque Byers)
InformationsquelleAutor nc3b
19

De la manuel:

Variables en faire peut venir de l'environnement dans lequel faire est d'exécuter. Chaque variable d'environnement qui font le voit lorsqu'il démarre est transformée en une variable avec le même nom et la valeur. Cependant, une affectation explicite dans le fichier makefile, ou avec un argument de la commande, les remplacements de l'environnement.

De sorte que vous pouvez faire (à partir de bash):
```
FOOBAR=1 make
```
résultant dans une variable FOOBAR dans votre Makefile.
- Je n'aime pas l'environnement de façon, mais merci
- L'autre moyen est en effet de mieux dans presque tous les cas. Je vais quitter cette ici par souci d'exhaustivité.
InformationsquelleAutor Thomas
4

Il y a une autre option de ne pas cités ici, qui est inclus dans le GNU Make livre par Stallman et McGrath (voir http://www.chemie.fu-berlin.de/chemnet/use/info/make/make_7.html). Il donne l'exemple:
```
archive.a: ...
ifneq (,$(findstring t,$(MAKEFLAGS)))
        +touch archive.a
        +ranlib -t archive.a
else
        ranlib archive.a
endif
```
Il consiste à vérifier si un paramètre apparaît dans MAKEFLAGS. Par exemple .. supposons que vous êtes étudiant à propos des threads en c++11 et vous avez divisé votre étude dans plusieurs fichiers (class01, ... , classNM) et que vous souhaitez: compiler ensuite tous et exécuter individuellement ou de compiler et de l'exécuter si un indicateur est spécifié (-r, par exemple). Donc, vous pouvez venir avec la suite de Makefile:
```
CXX=clang++-3.5
CXXFLAGS = -Wall -Werror -std=c++11
LDLIBS = -lpthread

SOURCES = class01 class02 class03

%: %.cxx
    $(CXX) $(CXXFLAGS) -o [email protected] $^ $(LDLIBS)
ifneq (,$(findstring r,  $(MAKEFLAGS)))
    ./[email protected]
endif

all: $(SOURCES)

.PHONY: clean

clean:
    find . -name "*.out" -delete
```
Avoir que, vous auriez:
- construire et d'exécuter un fichier w/make -r class02;
- construire tous les w/make ou make all;
- construire et d'exécuter tous les w/make -r (en supposant que tous d'entre eux contiennent un certain type d'affirmer des trucs et on a juste envie de toutes les tester)
InformationsquelleAutor Ciro Costa
3

Si vous faites un fichier appelé Makefile et ajouter une variable comme ceci $(unittest)
ensuite, vous serez en mesure d'utiliser cette variable dans le fichier Makefile, même avec des caractères génériques

exemple :
```
make unittest=*
```
- Je utiliser BOOST_TEST et en donnant un caractère générique au paramètre --run_test=$(unittest)
ensuite, je vais être en mesure d'utiliser une expression régulière pour filtrer le test, je veux que mon Makefile
pour exécuter

InformationsquelleAutor serup
3
```
export ROOT_DIR=<path/value>
```
Ensuite utiliser la variable, $(ROOT_DIR) dans le Makefile.

InformationsquelleAutor parasrish

Vous devez vous connecter pour publier un commentaire.