Elenca obiettivi / traguardi in GNU make che contengono variabili nella loro definizione

Ho un makefile abbastanza grande che crea un numero di obiettivi al volo calcolando i nomi dalle variabili. (es. foo $ (VAR): $ (PREREQS)). C'è un modo in cui gnu make può essere convinto a sputare un elenco di obiettivi dopo aver espanso queste variabili?

Mi piacerebbe essere in grado di ottenere gli obiettivi per un makefile arbitrario. Sto cercando di scrivere una funzione di completamento per la mia shell.

Puoi analizzare l'output da make -pn(ie make --print-data-base --dry-run)? Stampa tutte le variabili, le regole, le regole implicite e quali comandi verranno eseguiti nei minimi dettagli.

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

Tratto dal completamento make arg, che funziona come un fascino.

Non sono sicuro che questa sia solo una cosa creata da GNU, ma funziona bene:

make help

Diversi soccorritori hanno suggerito di utilizzare make -pn, che stamperà il database delle regole ma non eseguirà nulla, più o meno. Il problema con questo approccio è che -nrichiama ancora tutte le marche ricorsive e fa ancora molto più lavoro del necessario, perché stampa ogni comando che avrebbe richiamato in una normale build. Una soluzione più efficiente sarebbe creare un banale makefile, dummy.mk, con questi contenuti:

__all_targets__: ; #no-op

Ora invoca make as make -p -f Makefile -f dummy.mk __all_targets__. Su qualsiasi build sostanziale, la differenza nella quantità di output generata da make è significativa. Per esempio:

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

Anche il tempo di esecuzione è stato notevolmente migliore: 2,063 secondi per la prima versione, 0,059 secondi per la seconda.

Controlla il completamento di bash per make su GitHub.

Modifica: per tua informazione, il repository git del completamento di bash di debian in un'altra risposta ora incorpora una versione migliorata di questo script su misura per i casi d'uso del completamento di 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

Questo è uno script molto più completo dello script di completamento di debian bash perché fornisce i risultati per le regole generate che è ciò che la domanda richiede e la risposta più votata (script di completamento di debian bash sul server git debian) non va abbastanza lontano.

Questa non è la sceneggiatura originale a cui ho collegato, ma è molto più semplice ed è un tocco più veloce.

Questo è il codice per l'alias basato sulla soluzione di Todd Hodes

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

Questo darà un bel risultato:

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

C'è una soluzione molto carina con un po 'di magia sed ed egrep qui: https://gist.github.com/pvdb/777954

Immagino di essere un po 'in ritardo a questa festa, ma se stai cercando un comando specifico potresti provare

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

Questo per lo più funziona, anche se potrebbe ancora includere alcune cose non target come una vpathdirettiva. Se non dipendi dalle makeregole integrate di, puoi utilizzarlo make -qpRcome primo comando nella pipeline.

Soluzione rubino:

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

Sto lavorando su Solaris 10 e un guscio turbo C. La soluzione fornita non funziona per il mio progetto makefile. anche dopo aver modificato la riga di comando sopra alla sintassi tcsh. Tuttavia, ho scoperto che puoi ottenere una soluzione facile usando

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

versione remake:

remake --version

è

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

e alcuni altri dati di versione non importanti

Ho cercato la stessa domanda e ho pensato a questo giro:

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

Questo rimuove tutte le righe di commento, le regole del modello (righe che iniziano con le tabulazioni), tutti gli elementi intrinseci (esempio .c.oe %.o: %.cmodelli).

Ho trovato questa soluzione in un altro thread:

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

Puoi anche aggiungerlo al tuo Makefile:

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

Ed esegui make list.

Certo, ma quando vuoi che li sputi?

Per riportare il nome del target quando esegue la regola, inserisci una riga nella regola:

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

Per sputarli tutti in una volta, potresti creare un obiettivo PHONY separato:

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

E questo può essere considerato un prerequisito del tuo target predefinito:

all: show_vars
    ...

MODIFICARE:
vuoi un modo per mostrare tutti i possibili obiettivi di un makefile arbitrario, che suppongo significhi non intrusivo. Bene...

Per farlo esattamente ed essere in grado di gestire makefile sofisticati, ad esempio che coinvolgono regole costruite da evalistruzioni, dovresti scrivere qualcosa di simile a un emulatore Make. Poco pratico.

Per vedere gli obiettivi delle regole semplici, potresti scrivere un makefile che funga da scanner di makefile, operando su un makefile arbitrario:

1. Ottieni tutti i nomi di destinazione dal makefile usando sed.
2. `include` il makefile per usarlo per espandere le variabili.
3. Usa `show_%:; echo $$ * `per stampare tutti i target

Questo sarebbe un lavoro impressionante. Sei sicuro che l'obiettivo valga lo sforzo?

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