Liste des objectifs / cibles dans GNU make qui contiennent des variables dans leur définition

J'ai un makefile assez grand qui crée un certain nombre de cibles à la volée en calculant les noms à partir de variables. (par exemple foo $ (VAR): $ (PREREQS)). Est-il possible que gnu make puisse être convaincu de cracher une liste de cibles après avoir étendu ces variables?

J'aimerais pouvoir obtenir les cibles d'un makefile aribitrary. J'essaye d'écrire une fonction de complétion pour mon shell.

Pouvez-vous analyser la sortie de make -pn(ie make --print-data-base --dry-run)? Il imprime toutes les variables, règles, règles implicites et quelles commandes seront exécutées avec des détails laborieux.

make -qp | awk -F':' '/^[a-zA-Z0-9][^$#\/\t=]*:([^=]|$)/ {split($1,A,/ /);for(i in A)print A[i]}'     

Tiré de la finition make arg, qui fonctionne comme un charme.

Je ne suis pas sûr qu'il ne s'agisse que d'une création gnu, mais cela fonctionne bien:

make help

Plusieurs intervenants ont suggéré d'utiliser make -pn, qui imprimera la base de données des règles mais n'exécutera rien - plus ou moins. Le problème avec cette approche est qu'elle appelle -ntoujours toutes les marques récursives, et elle fait toujours beaucoup plus de travail que nécessaire, car elle imprime toutes les commandes qu'elle aurait appelées dans une construction régulière. Une solution plus efficace serait de créer un makefile trivial, dummy.mk, avec ce contenu:

__all_targets__: ; #no-op

Invoquez maintenant make as make -p -f Makefile -f dummy.mk __all_targets__. Sur toute construction substantielle, la différence dans la quantité de sortie générée par make est significative. Par exemple:

$ gmake -pn | wc
 138985 2632330 69612711
$ gmake -f Makefile -f /tmp/dummy.mk -pn __all_targets__ | wc
  21673   93437  878985

Le temps d'exécution était également nettement meilleur - 2,063s pour la première version, 0,059s pour la seconde.

Vérifiez l' achèvement de bash pour make sur GitHub.

Edit: Pour info, le référentiel de debian bash completion git dans une autre réponse intègre désormais une version améliorée de ce script adaptée aux cas d'utilisation de l'achèvement bash.

#!/bin/bash

SCRIPT='
  /^# Make data base/,/^# Files/d             # skip until files section
  /^# Not a target/,+1          d             # following target isnt
  /^\.PHONY:/                   d             # special target
  /^\.SUFFIXES:/                d             # special target
  /^\.DEFAULT:/                 d             # special target
  /^\.PRECIOUS:/                d             # special target
  /^\.INTERMEDIATE:/            d             # special target
  /^\.SECONDARY:/               d             # special target
  /^\.SECONDEXPANSION/          d             # special target
  /^\.DELETE_ON_ERROR:/         d             # special target
  /^\.IGNORE:/                  d             # special target
  /^\.LOW_RESOLUTION_TIME:/     d             # special target
  /^\.SILENT:/                  d             # special target
  /^\.EXPORT_ALL_VARIABLES:/    d             # special target
  /^\.NOTPARALLEL:/             d             # special target
  /^\.ONESHELL:/                d             # special target
  /^\.POSIX:/                   d             # special target
  /^\.NOEXPORT:/                d             # special target
  /^\.MAKE:/                    d             # special target

# The stuff above here describes lines that are not
#  explicit targets or not targets other than special ones
# The stuff below here decides whether an explicit target
#  should be output.

  /^[^#\t:=%]+:([^=]|$)/ {                    # found target block
    h                                         # hold target
    d                                         # delete line
  }
  /^# File is an intermediate prerequisite/ { # nope
    s/^.*$//;x                                # unhold target
    d                                         # delete line
  }
  /^([^#]|$)/ {                               # end of target block
    s/^.*$//;x                                # unhold target
    s/:.*$//p                                 # write current target
    d                                         # hide any bugs
  }
'

make -npq .DEFAULT 2>/dev/null | sed -n -r "$SCRIPT" \
  | sort | uniq

C'est un script beaucoup plus complet que le script d'achèvement debian bash car il fournit des résultats pour les règles générées, ce que la question demande et la réponse la plus votée (script d'achèvement debian bash sur le serveur debian git) ne va pas assez loin.

Ce n'est pas le script original auquel j'ai lié mais il est beaucoup plus simple et est un peu plus rapide.

Il s'agit du code d'alias basé sur la solution Todd Hodes

alias mtargets='make -qp | awk -F":" "/^[a-zA-Z0-9][^$#\/\t=]*:([^=]|$)/ {split(\$1,A,/ /);for(i in A)print A[i]}"'

Cela donnera une belle sortie:

make -pn | perl -F: -ane 'print "$F[0]\n" if /^\w+\s*:/' | sort

Il existe une très belle solution avec un peu de magie sed et egrep ici: https://gist.github.com/pvdb/777954

Je suppose que je suis un peu en retard à cette fête, mais si vous cherchez une commande spécifique, vous pouvez essayer

make -qp | grep -v '^# ' | grep -v '^[[:space:]]' | grep --only-matching '^.*:'

Cela fonctionne principalement, même si cela peut encore inclure des éléments non ciblés comme une vpathdirective. Si vous ne dépendez pas makedes règles intégrées de, vous pouvez utiliser make -qpRcomme première commande dans le pipeline.

Solution rubis:

`make -qp`.split("\n").select{|l| l =~ /^\w/ && l !~ /=/}.map{|l| l.sub(/:.*/,'')}

Je travaille sur Solaris 10 et une coque turbo C. La solution donnée ne fonctionne pas pour mon projet makefile. même après avoir modifié la ligne de commande ci-dessus en syntaxe tcsh. Cependant, j'ai découvert que vous pouvez obtenir une solution simple en utilisant

remake --tasks | grep -v "clean some static output or just grep tabs on start of line" | awk ´{print $1}´

refaire la version:

remake --version

est

GNU Make 3.82+dbg0.8
Built for sparc-sun-sparc2-9

et quelques autres données de version sans importance

Je suis allé à la recherche de la même question et j'ai proposé cette version:

make -pn | sed -rn '/^[^# \t\.%].*:/p'

Cela supprime toutes les lignes de commentaires, les règles de modèle (lignes commençant par des tabulations), tous les éléments intrinsèques (exemple .c.oet %.o: %.cmodèles).

J'ai trouvé cette solution dans un autre thread:

sh -c "cat Makefile | egrep \"^[[:alnum:][:punct:]]{0,}:[[:space:]]{0,}[[:alnum:][:punct:][:space:]]{0,}$\""

Vous pouvez également l'ajouter à votre Makefile:

list:
    sh -c "cat Makefile | egrep \"^[[:alnum:][:punct:]]{0,}:[[:space:]]{0,}[[:alnum:][:punct:][:space:]]{0,}$\\""

Et exécutez make list.

Bien sûr, mais quand voulez-vous qu'il les recrache?

Pour signaler le nom de la cible lorsqu'elle exécute la règle, placez une ligne dans la règle:

foo$(VAR): $(PREREQS)
    @echo now making the foo target: $@
    do_other_stuff...

Pour les recracher tous en même temps, vous pouvez créer une cible PHONY distincte:

.PHONY: show_vars
show_vars:
    @echo foo$(VAR)
    @echo bar$(PARAM) blah$(FLAG)
    # and so on

Et cela peut être une condition préalable de votre cible par défaut:

all: show_vars
    ...

EDIT:
Vous voulez un moyen d'afficher toutes les cibles possibles d'un makefile arbitraire, ce qui, je suppose, signifie de manière non intrusive. Bien...

Pour le faire exactement, et être capable de gérer des makefiles sophistiqués, par exemple impliquant des règles construites par des evalinstructions, il faudrait écrire quelque chose de proche d'un émulateur Make. Pas pratique.

Pour voir les cibles des règles simples, vous pouvez écrire un makefile qui agirait comme un scanner de makefile, fonctionnant sur un makefile arbitraire:

1. Obtenez tous les noms de cible du makefile en utilisant sed.
2. `include` le makefile afin de l'utiliser pour développer des variables.
3. Utilisez `show_%:; echo $$ * `pour imprimer toutes les cibles

Ce serait un travail impressionnant. Êtes-vous sûr que l'objectif en vaut la peine?

grep ^[a-z].*\:$ Makefile | sed s,:,,g